public inbox for libstdc++-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc r14-3247] libstdc++: Implement more maintainable <version> header
@ 2023-08-16 13:17 Arsen Arsenović
0 siblings, 0 replies; only message in thread
From: Arsen Arsenović @ 2023-08-16 13:17 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:b7b801b2f563b5f324805a85f5bea973a0daa65c
commit r14-3247-gb7b801b2f563b5f324805a85f5bea973a0daa65c
Author: Arsen Arsenović <arsen@aarsen.me>
Date: Mon Mar 27 15:29:08 2023 +0200
libstdc++: Implement more maintainable <version> header
This commit replaces the ad-hoc logic in <version> with an AutoGen
database that (mostly) declaratively generates a version.h bit which
combines all of the FTM logic across all headers together.
This generated header defines macros of the form __glibcxx_foo,
equivalent to their __cpp_lib_foo variants, according to rules specified
in version.def and, optionally, if __glibcxx_want_foo or
__glibcxx_want_all are defined, also defines __cpp_lib_foo forms with
the same definition.
libstdc++-v3/ChangeLog:
* include/Makefile.am (bits_freestanding): Add version.h.
(allcreated): Add version.h.
(${bits_srcdir}/version.h): New rule. Regenerates
version.h out of version.{def,tpl}.
* include/Makefile.in: Regenerate.
* include/bits/version.def: New file. Declares a list of
all feature test macros, their values and their preconditions.
* include/bits/version.tpl: New file. Turns version.def
into a sequence of #if blocks.
* include/bits/version.h: New file. Generated from
version.def.
* include/std/version: Replace with a __glibcxx_want_all define
and bits/version.h include.
Diff:
---
libstdc++-v3/include/Makefile.am | 10 +-
libstdc++-v3/include/Makefile.in | 10 +-
libstdc++-v3/include/bits/version.def | 1597 +++++++++++++++++++++++++++
libstdc++-v3/include/bits/version.h | 1942 +++++++++++++++++++++++++++++++++
libstdc++-v3/include/bits/version.tpl | 210 ++++
libstdc++-v3/include/std/version | 350 +-----
6 files changed, 3770 insertions(+), 349 deletions(-)
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index a880e8ee2275..9c71c75393aa 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -154,6 +154,7 @@ bits_freestanding = \
${bits_srcdir}/stl_raw_storage_iter.h \
${bits_srcdir}/stl_relops.h \
${bits_srcdir}/stl_uninitialized.h \
+ ${bits_srcdir}/version.h \
${bits_srcdir}/string_view.tcc \
${bits_srcdir}/uniform_int_dist.h \
${bits_srcdir}/unique_ptr.h \
@@ -1113,7 +1114,8 @@ allcreated = \
${host_builddir}/c++config.h \
${host_builddir}/largefile-config.h \
${thread_host_headers} \
- ${pch_build}
+ ${pch_build} \
+ ${bits_srcdir}/version.h
# Here are the rules for building the headers
all-local: ${allstamped} ${allcreated}
@@ -1463,6 +1465,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
-mkdir -p ${pch3_output_builddir}
$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
+# AutoGen <bits/version.h>.
+.PHONY: update-version
+update-version:
+ cd ${bits_srcdir} && \
+ autogen version.def
+
# The real deal.
install-data-local: install-headers
install-headers:
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index 0ff875b280be..f5b04d3fe8ae 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -509,6 +509,7 @@ bits_freestanding = \
${bits_srcdir}/stl_raw_storage_iter.h \
${bits_srcdir}/stl_relops.h \
${bits_srcdir}/stl_uninitialized.h \
+ ${bits_srcdir}/version.h \
${bits_srcdir}/string_view.tcc \
${bits_srcdir}/uniform_int_dist.h \
${bits_srcdir}/unique_ptr.h \
@@ -1441,7 +1442,8 @@ allcreated = \
${host_builddir}/c++config.h \
${host_builddir}/largefile-config.h \
${thread_host_headers} \
- ${pch_build}
+ ${pch_build} \
+ ${bits_srcdir}/version.h
# Host includes for threads
@@ -1937,6 +1939,12 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
-mkdir -p ${pch3_output_builddir}
$(CXX) $(PCHFLAGS) $(AM_CPPFLAGS) -O2 -g ${pch3_source} -o $@
+# AutoGen <bits/version.h>.
+${bits_srcdir}/version.h: ${bits_srcdir}/version.def \
+ ${bits_srcdir}/version.tpl
+ cd $(@D) && \
+ autogen version.def
+
# The real deal.
install-data-local: install-headers
install-headers:
diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def
new file mode 100644
index 000000000000..e63715e17e7b
--- /dev/null
+++ b/libstdc++-v3/include/bits/version.def
@@ -0,0 +1,1597 @@
+// Feature test macro definitions -*- C++ -*-
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+AutoGen Definitions version.tpl;
+
+// The top level variable ftms is an array of feature test macros. Each entry
+// consists of a structure like following:
+
+// Schema:
+// ftms = {
+// name = FTM NAME;
+// [stdname = FTM STANDARD MACRO NAME;]
+// values = {
+// v = VALUE FOR FTM IF MATCHING;
+// [extra_cond = STRING;]
+// [cxxmin = NUMBER;]
+// [gnuxxmin = NUMBER;]
+// [gthread = yes|no;]
+// [hosted = yes|no;]
+// [cxx11abi = yes|no;]
+// }; ...
+// };
+
+// The elements in square brackets are optional. These are formulated into a
+// logical expression like:
+// ((strict && c++ >= cxxmin) || (!strict && c++ >= gnuxxmin))
+// && (gthr <=> gthread)
+// && (host <=> hosted)
+// && (cxx11 <=> cxx11abi)
+// && (extra_cond)
+// Where gthr, cxx11 and host are _GLIBCXX_HAS_GTHREADS, _GLIBCXX_USE_CXX11_ABI
+// and _GLIBCXX_HOSTED respectively. If any of these are omitted, their
+// sub-expressions are equivalent to the identity. Specially, if gnuxxmin is
+// omitted, it is taken to be the value of cxxmin, and so, only if both are
+// omitted, the clause is omitted.
+
+// stdname configures the name of the *standard* macro emitted, i.e. it
+// replaces only the __cpp_lib_ macro in the emitted definition. Defaults to
+// __cpp_lib_${name}
+
+// N.B This list needs to be in topological sort order, as later entries in
+// this list can and do use the earlier entries.
+
+ftms = {
+ name = incomplete_container_elements;
+ values = {
+ v = 201505;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = uncaught_exceptions;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ gnuxxmin = 03;
+ };
+};
+
+ftms = {
+ name = allocator_traits_is_always_equal;
+ values = {
+ v = 201411;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = is_null_pointer;
+ values = {
+ v = 201309;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = result_of_sfinae;
+ values = {
+ v = 201210;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = shared_ptr_arrays;
+ values = {
+ v = 201707;
+ cxxmin = 20;
+ hosted = yes;
+ };
+ values = {
+ v = 201611;
+ cxxmin = 11;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = is_swappable;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ gnuxxmin = 11;
+ };
+};
+
+ftms = {
+ name = void_t;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ gnuxxmin = 11;
+ };
+};
+
+ftms = {
+ name = enable_shared_from_this;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ gnuxxmin = 11;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = math_spec_funcs;
+ stdname = "__STDCPP_MATH_SPEC_FUNCS__";
+ values = {
+ v = 201003;
+ cxxmin = 11;
+ };
+};
+
+ftms = {
+ name = coroutine;
+ values = {
+ v = 201902;
+ // It is very likely that earlier versions would work, but they are
+ // untested.
+ cxxmin = 14;
+ extra_cond = "__cpp_impl_coroutine";
+ };
+};
+
+ftms = {
+ name = exchange_function;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = integer_sequence;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = integral_constant_callable;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = is_final;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = make_reverse_iterator;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = null_iterators;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ extra_cond = "!defined(_GLIBCXX_DEBUG)";
+ };
+};
+
+ftms = {
+ name = transformation_trait_aliases;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = transparent_operators;
+ values = {
+ v = 201510;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = tuple_element_t;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = tuples_by_type;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = robust_nonmodifying_seq_ops;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ };
+};
+
+ftms = {
+ name = to_chars;
+ values = {
+ v = 201611;
+ cxxmin = 14;
+ extra_cond = "_GLIBCXX_FLOAT_IS_IEEE_BINARY32 "
+ "&& _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 "
+ "&& __SIZE_WIDTH__ >= 32";
+ };
+};
+
+ftms = {
+ name = chrono_udls;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = complex_udls;
+ values = {
+ v = 201309;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = generic_associative_lookup;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = make_unique;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = quoted_string_io;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = shared_timed_mutex;
+ values = {
+ v = 201402;
+ cxxmin = 14;
+ hosted = yes;
+ gthread = yes;
+ };
+};
+
+ftms = {
+ name = string_udls;
+ values = {
+ v = 201304;
+ cxxmin = 14;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = addressof_constexpr;
+ values = {
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2296. std::addressof should be constexpr
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = any;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = apply;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = as_const;
+ values = {
+ v = 201510;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = atomic_is_always_lock_free;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = bool_constant;
+ values = {
+ v = 201505;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = byte;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = has_unique_object_representations;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP)";
+ };
+};
+
+ftms = {
+ name = hardware_interference_size;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ extra_cond = "defined(__GCC_DESTRUCTIVE_SIZE)";
+ };
+};
+
+ftms = {
+ name = invoke;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = is_aggregate;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE)";
+ };
+};
+
+ftms = {
+ name = is_invocable;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = launder;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ extra_cond = "defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER)";
+ };
+};
+
+ftms = {
+ name = logical_traits;
+ values = {
+ v = 201510;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = make_from_tuple;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = not_fn;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = type_trait_variable_templates;
+ values = {
+ v = 201510;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = variant;
+ values = {
+ v = 202106;
+ cxxmin = 20;
+ extra_cond = "__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L";
+ };
+ values = {
+ v = 202102;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ // Used in earlier draft of SD6.
+ name = lcm;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ // Used in earlier draft of SD6.
+ name = gcd;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = gcd_lcm;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = raw_memory_algorithms;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = array_constexpr;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+ values = {
+ v = 201803;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = nonmember_container_access;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = clamp;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = sample;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = boyer_moore_searcher;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = chrono;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ };
+ values = {
+ v = 201611;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = execution;
+ values = {
+ v = 201902; // FIXME: should be 201603L
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = filesystem;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = hypot;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = map_try_emplace;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = math_special_functions;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = memory_resource;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ gthread = yes;
+ };
+ values = {
+ v = 1;
+ /* For when there's no gthread. */
+ cxxmin = 17;
+ hosted = yes;
+ gthread = no;
+ };
+};
+
+ftms = {
+ name = node_extract;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = parallel_algorithm;
+ values = {
+ v = 201603;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = scoped_lock;
+ values = {
+ v = 201703;
+ cxxmin = 17;
+ hosted = yes;
+ gthread = yes;
+ };
+};
+
+ftms = {
+ name = shared_mutex;
+ values = {
+ v = 201505;
+ cxxmin = 17;
+ hosted = yes;
+ gthread = yes;
+ };
+};
+
+ftms = {
+ name = shared_ptr_weak_type;
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = string_view;
+ values = {
+ v = 201803;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = unordered_map_try_emplace;
+ values = {
+ v = 201411;
+ cxxmin = 17;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = assume_aligned;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_flag_test;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_float;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_lock_free_type_aliases;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_ref;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_value_initialization;
+ values = {
+ v = 201911;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = bind_front;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = starts_ends_with;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = bit_cast;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ extra_cond = "__has_builtin(__builtin_bit_cast)";
+ };
+};
+
+ftms = {
+ name = bitops;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = bounded_array_traits;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = concepts;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ extra_cond = "__cpp_concepts >= 201907L";
+ };
+};
+
+// Moved down here (after concepts) by topological sort.
+ftms = {
+ name = optional;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ extra_cond = "__glibcxx_concepts";
+ };
+ values = {
+ v = 202106;
+ cxxmin = 20;
+ };
+ values = {
+ v = 201606;
+ cxxmin = 17;
+ };
+};
+
+ftms = {
+ name = destroying_delete;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ extra_cond = "__cpp_impl_destroying_delete";
+ };
+};
+
+ftms = {
+ name = constexpr_string_view;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = endian;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = int_pow2;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = integer_comparison_functions;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = is_constant_evaluated;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ extra_cond = "defined(_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)";
+ };
+};
+
+// Moved down here (after is_constant_evaluated) by topological sort.
+ftms = {
+ name = constexpr_char_traits;
+ values = {
+ // Unofficial macro indicating P1032R1 support in C++20
+ v = 201811;
+ cxxmin = 20;
+ extra_cond = "defined(__glibcxx_is_constant_evaluated)";
+ };
+ values = {
+ // Unofficial macro indicating P0426R1 support in C++17
+ v = 201611;
+ cxxmin = 17;
+ extra_cond = "_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED";
+ };
+};
+
+ftms = {
+ name = is_layout_compatible;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__has_builtin(__is_layout_compatible) "
+ "&& __has_builtin(__builtin_is_corresponding_member)";
+ };
+};
+
+ftms = {
+ name = is_nothrow_convertible;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = is_pointer_interconvertible;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond =
+ "__has_builtin(__is_pointer_interconvertible_base_of) "
+ "&& __has_builtin(__builtin_is_pointer_interconvertible_with_class)";
+ };
+};
+
+ftms = {
+ name = math_constants;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = make_obj_using_allocator;
+ values = {
+ // Not specified by C++20, used internally
+ v = 201811;
+ cxxmin = 20;
+ extra_cond = "__cpp_concepts";
+ };
+};
+
+ftms = {
+ name = remove_cvref;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = source_location;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__has_builtin(__builtin_source_location)";
+ };
+};
+
+ftms = {
+ name = span;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ extra_cond = "__glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = ssize;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = three_way_comparison;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__cpp_impl_three_way_comparison >= 201907L "
+ "&& __glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = to_address;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = to_array;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__cpp_generic_lambdas >= 201707L";
+ };
+};
+
+ftms = {
+ name = type_identity;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = unwrap_ref;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_iterator;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = interpolate;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_utility;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = shift;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = ranges;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ extra_cond = "__glibcxx_concepts";
+ };
+ values = {
+ v = 202110;
+ cxxmin = 20;
+ extra_cond = "__glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = constexpr_numeric;
+ values = {
+ v = 201911;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_functional;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_algorithms;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_tuple;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = constexpr_memory;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ extra_cond = "__cpp_constexpr_dynamic_alloc";
+ };
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = atomic_shared_ptr;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = atomic_wait;
+ // atomic_wait is available if either futexes or gthread are.
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ gthread = yes;
+ };
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ gthread = no;
+ extra_cond = "defined(_GLIBCXX_HAVE_LINUX_FUTEX)";
+ };
+};
+
+ftms = {
+ name = barrier;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ // This condition carries in the hosted&&(futex||gthread) logic from above.
+ extra_cond = "__cpp_aligned_new && __glibcxx_atomic_wait";
+ };
+};
+
+ftms = {
+ // 201907 Text Formatting, Integration of chrono, printf corner cases.
+ // 202106 std::format improvements.
+ // 202110 Fixing locale handling in chrono formatters, generator-like types.
+ // 202207 Encodings in localized formatting of chrono, basic-format-string.
+ // 202207 P2286R8 Formatting Ranges
+ // 202207 P2585R1 Improving default container formatting
+ // TODO: #define __cpp_lib_format_ranges 202207L
+ name = format;
+ values = {
+ v = 202106;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+// #undef __glibcxx_chrono
+// #define __glibcxx_chrono 201907L
+// FIXME: #define __glibcxx_execution 201902L
+
+ftms = {
+ name = constexpr_complex;
+ values = {
+ v = 201711;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = constexpr_dynamic_alloc;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = constexpr_string;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ cxx11abi = yes;
+ extra_cond = "defined(__glibcxx_is_constant_evaluated)";
+ };
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ hosted = yes;
+ cxx11abi = no;
+ extra_cond = "defined(__glibcxx_is_constant_evaluated)";
+ };
+ values = {
+ v = 201611;
+ cxxmin = 17;
+ hosted = yes;
+ extra_cond = "_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED";
+ };
+};
+
+ftms = {
+ name = constexpr_vector;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = erase_if;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = generic_unordered_lookup;
+ values = {
+ v = 201811;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = jthread;
+ values = {
+ v = 201911;
+ gthread = yes;
+ hosted = yes;
+ cxxmin = 20;
+ };
+};
+
+ftms = {
+ name = latch;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ extra_cond = "__glibcxx_atomic_wait";
+ };
+};
+
+ftms = {
+ name = list_remove_return_type;
+ values = {
+ v = 201806;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = polymorphic_allocator;
+ values = {
+ v = 201902;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = move_iterator_concept;
+ values = {
+ v = 202207;
+ // This is P2520R0, a C++23 change, but we treat it as a DR against C++20.
+ cxxmin = 20;
+ extra_cond = "__glibcxx_concepts";
+ };
+};
+
+ftms = {
+ name = semaphore;
+ values = {
+ v = 201907;
+ cxxmin = 20;
+ hosted = yes;
+ extra_cond = "__glibcxx_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE";
+ };
+};
+
+ftms = {
+ name = smart_ptr_for_overwrite;
+ values = {
+ v = 202002;
+ cxxmin = 20;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = syncbuf;
+ values = {
+ v = 201803;
+ cxxmin = 20;
+ hosted = yes;
+ cxx11abi = yes;
+ };
+};
+
+ftms = {
+ name = byteswap;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = constexpr_charconv;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = constexpr_typeinfo;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = expected;
+ values = {
+ v = 202211;
+ cxxmin = 23;
+ extra_cond = "__cpp_concepts >= 202002L";
+ };
+};
+
+ftms = {
+ name = invoke_r;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = is_scoped_enum;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = reference_from_temporary;
+ values = {
+ v = 202202;
+ extra_cond =
+ "__has_builtin(__reference_constructs_from_temporary) "
+ "&& __has_builtin(__reference_converts_from_temporary)";
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = to_underlying;
+ values = {
+ v = 202102;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = unreachable;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_zip;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_chunk;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_slide;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_chunk_by;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_join_with;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_repeat;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_stride;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_cartesian_product;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_as_rvalue;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_as_const;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_enumerate;
+ values = {
+ v = 202302;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_fold;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_contains;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_iota;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = ranges_find_last;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = constexpr_bitset;
+ values = {
+ v = 202202;
+ cxxmin = 23;
+ hosted = yes;
+ extra_cond = "__cpp_constexpr_dynamic_alloc";
+ };
+};
+
+ftms = {
+ name = stdatomic_h;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ };
+};
+
+ftms = {
+ name = adaptor_iterator_pair_constructor;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = ios_noreplace;
+ values = {
+ v = 202207;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = move_only_function;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = spanstream;
+ values = {
+ v = 202106;
+ cxxmin = 23;
+ hosted = yes;
+ extra_cond = "__glibcxx_span";
+ };
+};
+
+ftms = {
+ name = stacktrace;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ hosted = yes;
+ extra_cond = "_GLIBCXX_HAVE_STACKTRACE";
+ };
+};
+
+ftms = {
+ name = string_contains;
+ values = {
+ v = 202011;
+ cxxmin = 23;
+ hosted = yes;
+ };
+};
+
+ftms = {
+ name = string_resize_and_overwrite;
+ values = {
+ v = 202110;
+ cxxmin = 23;
+ hosted = yes;
+ cxx11abi = yes;
+ };
+};
+
+// Standard test specifications.
+stds[97] = ">= 199711L";
+stds[03] = ">= 199711L";
+stds[11] = ">= 201103L";
+stds[14] = ">= 201402L";
+stds[17] = ">= 201703L";
+stds[20] = ">= 202002L";
+stds[23] = "> 202002L"; // TODO: update when finalized
+
+// Local Variables:
+// compile-command: "autogen version.def"
+// End:
diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h
new file mode 100644
index 000000000000..5c5e7ff3264a
--- /dev/null
+++ b/libstdc++-v3/include/bits/version.h
@@ -0,0 +1,1942 @@
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+// DO NOT EDIT THIS FILE (version.h)
+//
+// It has been AutoGen-ed
+// From the definitions version.def
+// and the template file version.tpl
+
+/** @file bits/version.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{version}
+ */
+
+// Usage guide:
+//
+// In your usual header, do something like:
+//
+// #define __glibcxx_want_ranges
+// #define __glibcxx_want_concepts
+// #include <bits/version.h>
+//
+// This will generate the FTMs you named, and let you use them in your code as
+// if it was user code. All macros are also exposed under __glibcxx_NAME even
+// if unwanted, to permit bits and other FTMs to depend on them for condtional
+// computation without exposing extra FTMs to user code.
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+
+// from version.def line 65
+#if !defined(__cpp_lib_incomplete_container_elements)
+# if _GLIBCXX_HOSTED
+# define __glibcxx_incomplete_container_elements 201505L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_incomplete_container_elements)
+# define __cpp_lib_incomplete_container_elements 201505L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_incomplete_container_elements) && defined(__glibcxx_want_incomplete_container_elements) */
+#undef __glibcxx_want_incomplete_container_elements
+
+// from version.def line 73
+#if !defined(__cpp_lib_uncaught_exceptions)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 199711L))
+# define __glibcxx_uncaught_exceptions 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_uncaught_exceptions)
+# define __cpp_lib_uncaught_exceptions 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_uncaught_exceptions) && defined(__glibcxx_want_uncaught_exceptions) */
+#undef __glibcxx_want_uncaught_exceptions
+
+// from version.def line 82
+#if !defined(__cpp_lib_allocator_traits_is_always_equal)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_allocator_traits_is_always_equal 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_allocator_traits_is_always_equal)
+# define __cpp_lib_allocator_traits_is_always_equal 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_allocator_traits_is_always_equal) && defined(__glibcxx_want_allocator_traits_is_always_equal) */
+#undef __glibcxx_want_allocator_traits_is_always_equal
+
+// from version.def line 90
+#if !defined(__cpp_lib_is_null_pointer)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_is_null_pointer 201309L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_null_pointer)
+# define __cpp_lib_is_null_pointer 201309L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_null_pointer) && defined(__glibcxx_want_is_null_pointer) */
+#undef __glibcxx_want_is_null_pointer
+
+// from version.def line 98
+#if !defined(__cpp_lib_result_of_sfinae)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_result_of_sfinae 201210L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_result_of_sfinae)
+# define __cpp_lib_result_of_sfinae 201210L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_result_of_sfinae) && defined(__glibcxx_want_result_of_sfinae) */
+#undef __glibcxx_want_result_of_sfinae
+
+// from version.def line 106
+#if !defined(__cpp_lib_shared_ptr_arrays)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_ptr_arrays 201707L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_arrays)
+# define __cpp_lib_shared_ptr_arrays 201707L
+# endif
+# elif (__cplusplus >= 201103L) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_ptr_arrays 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_arrays)
+# define __cpp_lib_shared_ptr_arrays 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_ptr_arrays) && defined(__glibcxx_want_shared_ptr_arrays) */
+#undef __glibcxx_want_shared_ptr_arrays
+
+// from version.def line 120
+#if !defined(__cpp_lib_is_swappable)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L))
+# define __glibcxx_is_swappable 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_swappable)
+# define __cpp_lib_is_swappable 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_swappable) && defined(__glibcxx_want_is_swappable) */
+#undef __glibcxx_want_is_swappable
+
+// from version.def line 129
+#if !defined(__cpp_lib_void_t)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L))
+# define __glibcxx_void_t 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_void_t)
+# define __cpp_lib_void_t 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_void_t) && defined(__glibcxx_want_void_t) */
+#undef __glibcxx_want_void_t
+
+// from version.def line 138
+#if !defined(__cpp_lib_enable_shared_from_this)
+# if ((defined(__STRICT_ANSI__) && __cplusplus >= 201703L) || (!defined(__STRICT_ANSI__) && __cplusplus >= 201103L)) && _GLIBCXX_HOSTED
+# define __glibcxx_enable_shared_from_this 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_enable_shared_from_this)
+# define __cpp_lib_enable_shared_from_this 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_enable_shared_from_this) && defined(__glibcxx_want_enable_shared_from_this) */
+#undef __glibcxx_want_enable_shared_from_this
+
+// from version.def line 148
+#if !defined(__cpp_lib_math_spec_funcs)
+# if (__cplusplus >= 201103L)
+# define __glibcxx_math_spec_funcs 201003L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_spec_funcs)
+# define __STDCPP_MATH_SPEC_FUNCS__ 201003L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_math_spec_funcs) && defined(__glibcxx_want_math_spec_funcs) */
+#undef __glibcxx_want_math_spec_funcs
+
+// from version.def line 157
+#if !defined(__cpp_lib_coroutine)
+# if (__cplusplus >= 201402L) && (__cpp_impl_coroutine)
+# define __glibcxx_coroutine 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_coroutine)
+# define __cpp_lib_coroutine 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_coroutine) && defined(__glibcxx_want_coroutine) */
+#undef __glibcxx_want_coroutine
+
+// from version.def line 168
+#if !defined(__cpp_lib_exchange_function)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_exchange_function 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_exchange_function)
+# define __cpp_lib_exchange_function 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_exchange_function) && defined(__glibcxx_want_exchange_function) */
+#undef __glibcxx_want_exchange_function
+
+// from version.def line 176
+#if !defined(__cpp_lib_integer_sequence)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_integer_sequence 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integer_sequence)
+# define __cpp_lib_integer_sequence 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_integer_sequence) && defined(__glibcxx_want_integer_sequence) */
+#undef __glibcxx_want_integer_sequence
+
+// from version.def line 184
+#if !defined(__cpp_lib_integral_constant_callable)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_integral_constant_callable 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integral_constant_callable)
+# define __cpp_lib_integral_constant_callable 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_integral_constant_callable) && defined(__glibcxx_want_integral_constant_callable) */
+#undef __glibcxx_want_integral_constant_callable
+
+// from version.def line 192
+#if !defined(__cpp_lib_is_final)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_is_final 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_final)
+# define __cpp_lib_is_final 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_final) && defined(__glibcxx_want_is_final) */
+#undef __glibcxx_want_is_final
+
+// from version.def line 200
+#if !defined(__cpp_lib_make_reverse_iterator)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_make_reverse_iterator 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_reverse_iterator)
+# define __cpp_lib_make_reverse_iterator 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_reverse_iterator) && defined(__glibcxx_want_make_reverse_iterator) */
+#undef __glibcxx_want_make_reverse_iterator
+
+// from version.def line 208
+#if !defined(__cpp_lib_null_iterators)
+# if (__cplusplus >= 201402L) && (!defined(_GLIBCXX_DEBUG))
+# define __glibcxx_null_iterators 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_null_iterators)
+# define __cpp_lib_null_iterators 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_null_iterators) && defined(__glibcxx_want_null_iterators) */
+#undef __glibcxx_want_null_iterators
+
+// from version.def line 217
+#if !defined(__cpp_lib_transformation_trait_aliases)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_transformation_trait_aliases 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_transformation_trait_aliases)
+# define __cpp_lib_transformation_trait_aliases 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_transformation_trait_aliases) && defined(__glibcxx_want_transformation_trait_aliases) */
+#undef __glibcxx_want_transformation_trait_aliases
+
+// from version.def line 225
+#if !defined(__cpp_lib_transparent_operators)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_transparent_operators 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_transparent_operators)
+# define __cpp_lib_transparent_operators 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_transparent_operators) && defined(__glibcxx_want_transparent_operators) */
+#undef __glibcxx_want_transparent_operators
+
+// from version.def line 233
+#if !defined(__cpp_lib_tuple_element_t)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_tuple_element_t 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_tuple_element_t)
+# define __cpp_lib_tuple_element_t 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_tuple_element_t) && defined(__glibcxx_want_tuple_element_t) */
+#undef __glibcxx_want_tuple_element_t
+
+// from version.def line 241
+#if !defined(__cpp_lib_tuples_by_type)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_tuples_by_type 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_tuples_by_type)
+# define __cpp_lib_tuples_by_type 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_tuples_by_type) && defined(__glibcxx_want_tuples_by_type) */
+#undef __glibcxx_want_tuples_by_type
+
+// from version.def line 249
+#if !defined(__cpp_lib_robust_nonmodifying_seq_ops)
+# if (__cplusplus >= 201402L)
+# define __glibcxx_robust_nonmodifying_seq_ops 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_robust_nonmodifying_seq_ops)
+# define __cpp_lib_robust_nonmodifying_seq_ops 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_robust_nonmodifying_seq_ops) && defined(__glibcxx_want_robust_nonmodifying_seq_ops) */
+#undef __glibcxx_want_robust_nonmodifying_seq_ops
+
+// from version.def line 257
+#if !defined(__cpp_lib_to_chars)
+# if (__cplusplus >= 201402L) && (_GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 && __SIZE_WIDTH__ >= 32)
+# define __glibcxx_to_chars 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_chars)
+# define __cpp_lib_to_chars 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_chars) && defined(__glibcxx_want_to_chars) */
+#undef __glibcxx_want_to_chars
+
+// from version.def line 268
+#if !defined(__cpp_lib_chrono_udls)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_chrono_udls 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono_udls)
+# define __cpp_lib_chrono_udls 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_chrono_udls) && defined(__glibcxx_want_chrono_udls) */
+#undef __glibcxx_want_chrono_udls
+
+// from version.def line 277
+#if !defined(__cpp_lib_complex_udls)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_complex_udls 201309L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_complex_udls)
+# define __cpp_lib_complex_udls 201309L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_complex_udls) && defined(__glibcxx_want_complex_udls) */
+#undef __glibcxx_want_complex_udls
+
+// from version.def line 286
+#if !defined(__cpp_lib_generic_associative_lookup)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_generic_associative_lookup 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generic_associative_lookup)
+# define __cpp_lib_generic_associative_lookup 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_generic_associative_lookup) && defined(__glibcxx_want_generic_associative_lookup) */
+#undef __glibcxx_want_generic_associative_lookup
+
+// from version.def line 295
+#if !defined(__cpp_lib_make_unique)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_make_unique 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_unique)
+# define __cpp_lib_make_unique 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_unique) && defined(__glibcxx_want_make_unique) */
+#undef __glibcxx_want_make_unique
+
+// from version.def line 304
+#if !defined(__cpp_lib_quoted_string_io)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_quoted_string_io 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_quoted_string_io)
+# define __cpp_lib_quoted_string_io 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_quoted_string_io) && defined(__glibcxx_want_quoted_string_io) */
+#undef __glibcxx_want_quoted_string_io
+
+// from version.def line 313
+#if !defined(__cpp_lib_shared_timed_mutex)
+# if (__cplusplus >= 201402L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_timed_mutex 201402L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_timed_mutex)
+# define __cpp_lib_shared_timed_mutex 201402L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_timed_mutex) && defined(__glibcxx_want_shared_timed_mutex) */
+#undef __glibcxx_want_shared_timed_mutex
+
+// from version.def line 323
+#if !defined(__cpp_lib_string_udls)
+# if (__cplusplus >= 201402L) && _GLIBCXX_HOSTED
+# define __glibcxx_string_udls 201304L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_udls)
+# define __cpp_lib_string_udls 201304L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_udls) && defined(__glibcxx_want_string_udls) */
+#undef __glibcxx_want_string_udls
+
+// from version.def line 332
+#if !defined(__cpp_lib_addressof_constexpr)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_addressof_constexpr 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_addressof_constexpr)
+# define __cpp_lib_addressof_constexpr 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_addressof_constexpr) && defined(__glibcxx_want_addressof_constexpr) */
+#undef __glibcxx_want_addressof_constexpr
+
+// from version.def line 342
+#if !defined(__cpp_lib_any)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_any 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_any)
+# define __cpp_lib_any 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_any) && defined(__glibcxx_want_any) */
+#undef __glibcxx_want_any
+
+// from version.def line 350
+#if !defined(__cpp_lib_apply)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_apply 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_apply)
+# define __cpp_lib_apply 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_apply) && defined(__glibcxx_want_apply) */
+#undef __glibcxx_want_apply
+
+// from version.def line 358
+#if !defined(__cpp_lib_as_const)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_as_const 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_as_const)
+# define __cpp_lib_as_const 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_as_const) && defined(__glibcxx_want_as_const) */
+#undef __glibcxx_want_as_const
+
+// from version.def line 366
+#if !defined(__cpp_lib_atomic_is_always_lock_free)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_atomic_is_always_lock_free 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_is_always_lock_free)
+# define __cpp_lib_atomic_is_always_lock_free 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_is_always_lock_free) && defined(__glibcxx_want_atomic_is_always_lock_free) */
+#undef __glibcxx_want_atomic_is_always_lock_free
+
+// from version.def line 374
+#if !defined(__cpp_lib_bool_constant)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_bool_constant 201505L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bool_constant)
+# define __cpp_lib_bool_constant 201505L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bool_constant) && defined(__glibcxx_want_bool_constant) */
+#undef __glibcxx_want_bool_constant
+
+// from version.def line 382
+#if !defined(__cpp_lib_byte)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_byte 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_byte)
+# define __cpp_lib_byte 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_byte) && defined(__glibcxx_want_byte) */
+#undef __glibcxx_want_byte
+
+// from version.def line 390
+#if !defined(__cpp_lib_has_unique_object_representations)
+# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP))
+# define __glibcxx_has_unique_object_representations 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_has_unique_object_representations)
+# define __cpp_lib_has_unique_object_representations 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_has_unique_object_representations) && defined(__glibcxx_want_has_unique_object_representations) */
+#undef __glibcxx_want_has_unique_object_representations
+
+// from version.def line 399
+#if !defined(__cpp_lib_hardware_interference_size)
+# if (__cplusplus >= 201703L) && (defined(__GCC_DESTRUCTIVE_SIZE))
+# define __glibcxx_hardware_interference_size 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_hardware_interference_size)
+# define __cpp_lib_hardware_interference_size 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_hardware_interference_size) && defined(__glibcxx_want_hardware_interference_size) */
+#undef __glibcxx_want_hardware_interference_size
+
+// from version.def line 408
+#if !defined(__cpp_lib_invoke)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_invoke 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_invoke)
+# define __cpp_lib_invoke 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_invoke) && defined(__glibcxx_want_invoke) */
+#undef __glibcxx_want_invoke
+
+// from version.def line 416
+#if !defined(__cpp_lib_is_aggregate)
+# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE))
+# define __glibcxx_is_aggregate 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_aggregate)
+# define __cpp_lib_is_aggregate 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_aggregate) && defined(__glibcxx_want_is_aggregate) */
+#undef __glibcxx_want_is_aggregate
+
+// from version.def line 425
+#if !defined(__cpp_lib_is_invocable)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_is_invocable 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_invocable)
+# define __cpp_lib_is_invocable 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_invocable) && defined(__glibcxx_want_is_invocable) */
+#undef __glibcxx_want_is_invocable
+
+// from version.def line 433
+#if !defined(__cpp_lib_launder)
+# if (__cplusplus >= 201703L) && (defined(_GLIBCXX_HAVE_BUILTIN_LAUNDER))
+# define __glibcxx_launder 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_launder)
+# define __cpp_lib_launder 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_launder) && defined(__glibcxx_want_launder) */
+#undef __glibcxx_want_launder
+
+// from version.def line 442
+#if !defined(__cpp_lib_logical_traits)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_logical_traits 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_logical_traits)
+# define __cpp_lib_logical_traits 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_logical_traits) && defined(__glibcxx_want_logical_traits) */
+#undef __glibcxx_want_logical_traits
+
+// from version.def line 450
+#if !defined(__cpp_lib_make_from_tuple)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_make_from_tuple 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_from_tuple)
+# define __cpp_lib_make_from_tuple 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_from_tuple) && defined(__glibcxx_want_make_from_tuple) */
+#undef __glibcxx_want_make_from_tuple
+
+// from version.def line 458
+#if !defined(__cpp_lib_not_fn)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_not_fn 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_not_fn)
+# define __cpp_lib_not_fn 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_not_fn) && defined(__glibcxx_want_not_fn) */
+#undef __glibcxx_want_not_fn
+
+// from version.def line 466
+#if !defined(__cpp_lib_type_trait_variable_templates)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_type_trait_variable_templates 201510L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_type_trait_variable_templates)
+# define __cpp_lib_type_trait_variable_templates 201510L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_type_trait_variable_templates) && defined(__glibcxx_want_type_trait_variable_templates) */
+#undef __glibcxx_want_type_trait_variable_templates
+
+// from version.def line 474
+#if !defined(__cpp_lib_variant)
+# if (__cplusplus >= 202002L) && (__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L)
+# define __glibcxx_variant 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_variant)
+# define __cpp_lib_variant 202106L
+# endif
+# elif (__cplusplus >= 201703L)
+# define __glibcxx_variant 202102L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_variant)
+# define __cpp_lib_variant 202102L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_variant) && defined(__glibcxx_want_variant) */
+#undef __glibcxx_want_variant
+
+// from version.def line 488
+#if !defined(__cpp_lib_lcm)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_lcm 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_lcm)
+# define __cpp_lib_lcm 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_lcm) && defined(__glibcxx_want_lcm) */
+#undef __glibcxx_want_lcm
+
+// from version.def line 497
+#if !defined(__cpp_lib_gcd)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_gcd 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_gcd)
+# define __cpp_lib_gcd 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_gcd) && defined(__glibcxx_want_gcd) */
+#undef __glibcxx_want_gcd
+
+// from version.def line 505
+#if !defined(__cpp_lib_gcd_lcm)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_gcd_lcm 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_gcd_lcm)
+# define __cpp_lib_gcd_lcm 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_gcd_lcm) && defined(__glibcxx_want_gcd_lcm) */
+#undef __glibcxx_want_gcd_lcm
+
+// from version.def line 513
+#if !defined(__cpp_lib_raw_memory_algorithms)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_raw_memory_algorithms 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_raw_memory_algorithms)
+# define __cpp_lib_raw_memory_algorithms 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_raw_memory_algorithms) && defined(__glibcxx_want_raw_memory_algorithms) */
+#undef __glibcxx_want_raw_memory_algorithms
+
+// from version.def line 521
+#if !defined(__cpp_lib_array_constexpr)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_array_constexpr 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_array_constexpr)
+# define __cpp_lib_array_constexpr 201811L
+# endif
+# elif (__cplusplus >= 201703L)
+# define __glibcxx_array_constexpr 201803L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_array_constexpr)
+# define __cpp_lib_array_constexpr 201803L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_array_constexpr) && defined(__glibcxx_want_array_constexpr) */
+#undef __glibcxx_want_array_constexpr
+
+// from version.def line 533
+#if !defined(__cpp_lib_nonmember_container_access)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_nonmember_container_access 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_nonmember_container_access)
+# define __cpp_lib_nonmember_container_access 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_nonmember_container_access) && defined(__glibcxx_want_nonmember_container_access) */
+#undef __glibcxx_want_nonmember_container_access
+
+// from version.def line 541
+#if !defined(__cpp_lib_clamp)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_clamp 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_clamp)
+# define __cpp_lib_clamp 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_clamp) && defined(__glibcxx_want_clamp) */
+#undef __glibcxx_want_clamp
+
+// from version.def line 549
+#if !defined(__cpp_lib_sample)
+# if (__cplusplus >= 201703L)
+# define __glibcxx_sample 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_sample)
+# define __cpp_lib_sample 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_sample) && defined(__glibcxx_want_sample) */
+#undef __glibcxx_want_sample
+
+// from version.def line 557
+#if !defined(__cpp_lib_boyer_moore_searcher)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_boyer_moore_searcher 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_boyer_moore_searcher)
+# define __cpp_lib_boyer_moore_searcher 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_boyer_moore_searcher) && defined(__glibcxx_want_boyer_moore_searcher) */
+#undef __glibcxx_want_boyer_moore_searcher
+
+// from version.def line 566
+#if !defined(__cpp_lib_chrono)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_chrono 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono)
+# define __cpp_lib_chrono 201907L
+# endif
+# elif (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_chrono 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_chrono)
+# define __cpp_lib_chrono 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_chrono) && defined(__glibcxx_want_chrono) */
+#undef __glibcxx_want_chrono
+
+// from version.def line 580
+#if !defined(__cpp_lib_execution)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_execution 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_execution)
+# define __cpp_lib_execution 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_execution) && defined(__glibcxx_want_execution) */
+#undef __glibcxx_want_execution
+
+// from version.def line 589
+#if !defined(__cpp_lib_filesystem)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_filesystem 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_filesystem)
+# define __cpp_lib_filesystem 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_filesystem) && defined(__glibcxx_want_filesystem) */
+#undef __glibcxx_want_filesystem
+
+// from version.def line 598
+#if !defined(__cpp_lib_hypot)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_hypot 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_hypot)
+# define __cpp_lib_hypot 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_hypot) && defined(__glibcxx_want_hypot) */
+#undef __glibcxx_want_hypot
+
+// from version.def line 607
+#if !defined(__cpp_lib_map_try_emplace)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_map_try_emplace 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_map_try_emplace)
+# define __cpp_lib_map_try_emplace 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_map_try_emplace) && defined(__glibcxx_want_map_try_emplace) */
+#undef __glibcxx_want_map_try_emplace
+
+// from version.def line 616
+#if !defined(__cpp_lib_math_special_functions)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_math_special_functions 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_special_functions)
+# define __cpp_lib_math_special_functions 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_math_special_functions) && defined(__glibcxx_want_math_special_functions) */
+#undef __glibcxx_want_math_special_functions
+
+// from version.def line 625
+#if !defined(__cpp_lib_memory_resource)
+# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_memory_resource 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_memory_resource)
+# define __cpp_lib_memory_resource 201603L
+# endif
+# elif (__cplusplus >= 201703L) && !defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_memory_resource 1L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_memory_resource)
+# define __cpp_lib_memory_resource 1L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_memory_resource) && defined(__glibcxx_want_memory_resource) */
+#undef __glibcxx_want_memory_resource
+
+// from version.def line 642
+#if !defined(__cpp_lib_node_extract)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_node_extract 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_node_extract)
+# define __cpp_lib_node_extract 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_node_extract) && defined(__glibcxx_want_node_extract) */
+#undef __glibcxx_want_node_extract
+
+// from version.def line 651
+#if !defined(__cpp_lib_parallel_algorithm)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_parallel_algorithm 201603L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_parallel_algorithm)
+# define __cpp_lib_parallel_algorithm 201603L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_parallel_algorithm) && defined(__glibcxx_want_parallel_algorithm) */
+#undef __glibcxx_want_parallel_algorithm
+
+// from version.def line 660
+#if !defined(__cpp_lib_scoped_lock)
+# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_scoped_lock 201703L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_scoped_lock)
+# define __cpp_lib_scoped_lock 201703L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_scoped_lock) && defined(__glibcxx_want_scoped_lock) */
+#undef __glibcxx_want_scoped_lock
+
+// from version.def line 670
+#if !defined(__cpp_lib_shared_mutex)
+# if (__cplusplus >= 201703L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_mutex 201505L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_mutex)
+# define __cpp_lib_shared_mutex 201505L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_mutex) && defined(__glibcxx_want_shared_mutex) */
+#undef __glibcxx_want_shared_mutex
+
+// from version.def line 680
+#if !defined(__cpp_lib_shared_ptr_weak_type)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_shared_ptr_weak_type 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shared_ptr_weak_type)
+# define __cpp_lib_shared_ptr_weak_type 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shared_ptr_weak_type) && defined(__glibcxx_want_shared_ptr_weak_type) */
+#undef __glibcxx_want_shared_ptr_weak_type
+
+// from version.def line 689
+#if !defined(__cpp_lib_string_view)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_string_view 201803L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_view)
+# define __cpp_lib_string_view 201803L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_view) && defined(__glibcxx_want_string_view) */
+#undef __glibcxx_want_string_view
+
+// from version.def line 698
+#if !defined(__cpp_lib_unordered_map_try_emplace)
+# if (__cplusplus >= 201703L) && _GLIBCXX_HOSTED
+# define __glibcxx_unordered_map_try_emplace 201411L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unordered_map_try_emplace)
+# define __cpp_lib_unordered_map_try_emplace 201411L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_unordered_map_try_emplace) && defined(__glibcxx_want_unordered_map_try_emplace) */
+#undef __glibcxx_want_unordered_map_try_emplace
+
+// from version.def line 707
+#if !defined(__cpp_lib_assume_aligned)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_assume_aligned 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_assume_aligned)
+# define __cpp_lib_assume_aligned 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_assume_aligned) && defined(__glibcxx_want_assume_aligned) */
+#undef __glibcxx_want_assume_aligned
+
+// from version.def line 715
+#if !defined(__cpp_lib_atomic_flag_test)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_flag_test 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_flag_test)
+# define __cpp_lib_atomic_flag_test 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_flag_test) && defined(__glibcxx_want_atomic_flag_test) */
+#undef __glibcxx_want_atomic_flag_test
+
+// from version.def line 723
+#if !defined(__cpp_lib_atomic_float)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_float 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_float)
+# define __cpp_lib_atomic_float 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_float) && defined(__glibcxx_want_atomic_float) */
+#undef __glibcxx_want_atomic_float
+
+// from version.def line 731
+#if !defined(__cpp_lib_atomic_lock_free_type_aliases)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_lock_free_type_aliases 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_lock_free_type_aliases)
+# define __cpp_lib_atomic_lock_free_type_aliases 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_lock_free_type_aliases) && defined(__glibcxx_want_atomic_lock_free_type_aliases) */
+#undef __glibcxx_want_atomic_lock_free_type_aliases
+
+// from version.def line 739
+#if !defined(__cpp_lib_atomic_ref)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_ref 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_ref)
+# define __cpp_lib_atomic_ref 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_ref) && defined(__glibcxx_want_atomic_ref) */
+#undef __glibcxx_want_atomic_ref
+
+// from version.def line 747
+#if !defined(__cpp_lib_atomic_value_initialization)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_atomic_value_initialization 201911L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_value_initialization)
+# define __cpp_lib_atomic_value_initialization 201911L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_value_initialization) && defined(__glibcxx_want_atomic_value_initialization) */
+#undef __glibcxx_want_atomic_value_initialization
+
+// from version.def line 755
+#if !defined(__cpp_lib_bind_front)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_bind_front 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bind_front)
+# define __cpp_lib_bind_front 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bind_front) && defined(__glibcxx_want_bind_front) */
+#undef __glibcxx_want_bind_front
+
+// from version.def line 763
+#if !defined(__cpp_lib_starts_ends_with)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_starts_ends_with 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_starts_ends_with)
+# define __cpp_lib_starts_ends_with 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_starts_ends_with) && defined(__glibcxx_want_starts_ends_with) */
+#undef __glibcxx_want_starts_ends_with
+
+// from version.def line 771
+#if !defined(__cpp_lib_bit_cast)
+# if (__cplusplus >= 202002L) && (__has_builtin(__builtin_bit_cast))
+# define __glibcxx_bit_cast 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bit_cast)
+# define __cpp_lib_bit_cast 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bit_cast) && defined(__glibcxx_want_bit_cast) */
+#undef __glibcxx_want_bit_cast
+
+// from version.def line 780
+#if !defined(__cpp_lib_bitops)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_bitops 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bitops)
+# define __cpp_lib_bitops 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bitops) && defined(__glibcxx_want_bitops) */
+#undef __glibcxx_want_bitops
+
+// from version.def line 788
+#if !defined(__cpp_lib_bounded_array_traits)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_bounded_array_traits 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_bounded_array_traits)
+# define __cpp_lib_bounded_array_traits 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_bounded_array_traits) && defined(__glibcxx_want_bounded_array_traits) */
+#undef __glibcxx_want_bounded_array_traits
+
+// from version.def line 796
+#if !defined(__cpp_lib_concepts)
+# if (__cplusplus >= 202002L) && (__cpp_concepts >= 201907L)
+# define __glibcxx_concepts 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_concepts)
+# define __cpp_lib_concepts 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_concepts) && defined(__glibcxx_want_concepts) */
+#undef __glibcxx_want_concepts
+
+// from version.def line 806
+#if !defined(__cpp_lib_optional)
+# if (__cplusplus > 202002L) && (__glibcxx_concepts)
+# define __glibcxx_optional 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional)
+# define __cpp_lib_optional 202110L
+# endif
+# elif (__cplusplus >= 202002L)
+# define __glibcxx_optional 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional)
+# define __cpp_lib_optional 202106L
+# endif
+# elif (__cplusplus >= 201703L)
+# define __glibcxx_optional 201606L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_optional)
+# define __cpp_lib_optional 201606L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_optional) && defined(__glibcxx_want_optional) */
+#undef __glibcxx_want_optional
+
+// from version.def line 823
+#if !defined(__cpp_lib_destroying_delete)
+# if (__cplusplus >= 202002L) && (__cpp_impl_destroying_delete)
+# define __glibcxx_destroying_delete 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_destroying_delete)
+# define __cpp_lib_destroying_delete 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_destroying_delete) && defined(__glibcxx_want_destroying_delete) */
+#undef __glibcxx_want_destroying_delete
+
+// from version.def line 832
+#if !defined(__cpp_lib_constexpr_string_view)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_string_view 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string_view)
+# define __cpp_lib_constexpr_string_view 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_string_view) && defined(__glibcxx_want_constexpr_string_view) */
+#undef __glibcxx_want_constexpr_string_view
+
+// from version.def line 840
+#if !defined(__cpp_lib_endian)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_endian 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_endian)
+# define __cpp_lib_endian 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_endian) && defined(__glibcxx_want_endian) */
+#undef __glibcxx_want_endian
+
+// from version.def line 848
+#if !defined(__cpp_lib_int_pow2)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_int_pow2 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_int_pow2)
+# define __cpp_lib_int_pow2 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_int_pow2) && defined(__glibcxx_want_int_pow2) */
+#undef __glibcxx_want_int_pow2
+
+// from version.def line 856
+#if !defined(__cpp_lib_integer_comparison_functions)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_integer_comparison_functions 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_integer_comparison_functions)
+# define __cpp_lib_integer_comparison_functions 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_integer_comparison_functions) && defined(__glibcxx_want_integer_comparison_functions) */
+#undef __glibcxx_want_integer_comparison_functions
+
+// from version.def line 864
+#if !defined(__cpp_lib_is_constant_evaluated)
+# if (__cplusplus >= 202002L) && (defined(_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED))
+# define __glibcxx_is_constant_evaluated 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_constant_evaluated)
+# define __cpp_lib_is_constant_evaluated 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_constant_evaluated) && defined(__glibcxx_want_is_constant_evaluated) */
+#undef __glibcxx_want_is_constant_evaluated
+
+// from version.def line 874
+#if !defined(__cpp_lib_constexpr_char_traits)
+# if (__cplusplus >= 202002L) && (defined(__glibcxx_is_constant_evaluated))
+# define __glibcxx_constexpr_char_traits 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_char_traits)
+# define __cpp_lib_constexpr_char_traits 201811L
+# endif
+# elif (__cplusplus >= 201703L) && (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)
+# define __glibcxx_constexpr_char_traits 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_char_traits)
+# define __cpp_lib_constexpr_char_traits 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_char_traits) && defined(__glibcxx_want_constexpr_char_traits) */
+#undef __glibcxx_want_constexpr_char_traits
+
+// from version.def line 890
+#if !defined(__cpp_lib_is_layout_compatible)
+# if (__cplusplus >= 202002L) && (__has_builtin(__is_layout_compatible) && __has_builtin(__builtin_is_corresponding_member))
+# define __glibcxx_is_layout_compatible 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_layout_compatible)
+# define __cpp_lib_is_layout_compatible 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_layout_compatible) && defined(__glibcxx_want_is_layout_compatible) */
+#undef __glibcxx_want_is_layout_compatible
+
+// from version.def line 900
+#if !defined(__cpp_lib_is_nothrow_convertible)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_is_nothrow_convertible 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_nothrow_convertible)
+# define __cpp_lib_is_nothrow_convertible 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_nothrow_convertible) && defined(__glibcxx_want_is_nothrow_convertible) */
+#undef __glibcxx_want_is_nothrow_convertible
+
+// from version.def line 908
+#if !defined(__cpp_lib_is_pointer_interconvertible)
+# if (__cplusplus >= 202002L) && (__has_builtin(__is_pointer_interconvertible_base_of) && __has_builtin(__builtin_is_pointer_interconvertible_with_class))
+# define __glibcxx_is_pointer_interconvertible 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_pointer_interconvertible)
+# define __cpp_lib_is_pointer_interconvertible 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_pointer_interconvertible) && defined(__glibcxx_want_is_pointer_interconvertible) */
+#undef __glibcxx_want_is_pointer_interconvertible
+
+// from version.def line 919
+#if !defined(__cpp_lib_math_constants)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_math_constants 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_math_constants)
+# define __cpp_lib_math_constants 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_math_constants) && defined(__glibcxx_want_math_constants) */
+#undef __glibcxx_want_math_constants
+
+// from version.def line 927
+#if !defined(__cpp_lib_make_obj_using_allocator)
+# if (__cplusplus >= 202002L) && (__cpp_concepts)
+# define __glibcxx_make_obj_using_allocator 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_make_obj_using_allocator)
+# define __cpp_lib_make_obj_using_allocator 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_make_obj_using_allocator) && defined(__glibcxx_want_make_obj_using_allocator) */
+#undef __glibcxx_want_make_obj_using_allocator
+
+// from version.def line 937
+#if !defined(__cpp_lib_remove_cvref)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_remove_cvref 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_remove_cvref)
+# define __cpp_lib_remove_cvref 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_remove_cvref) && defined(__glibcxx_want_remove_cvref) */
+#undef __glibcxx_want_remove_cvref
+
+// from version.def line 945
+#if !defined(__cpp_lib_source_location)
+# if (__cplusplus >= 202002L) && (__has_builtin(__builtin_source_location))
+# define __glibcxx_source_location 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_source_location)
+# define __cpp_lib_source_location 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_source_location) && defined(__glibcxx_want_source_location) */
+#undef __glibcxx_want_source_location
+
+// from version.def line 954
+#if !defined(__cpp_lib_span)
+# if (__cplusplus >= 202002L) && (__glibcxx_concepts)
+# define __glibcxx_span 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_span)
+# define __cpp_lib_span 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_span) && defined(__glibcxx_want_span) */
+#undef __glibcxx_want_span
+
+// from version.def line 963
+#if !defined(__cpp_lib_ssize)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_ssize 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ssize)
+# define __cpp_lib_ssize 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ssize) && defined(__glibcxx_want_ssize) */
+#undef __glibcxx_want_ssize
+
+// from version.def line 971
+#if !defined(__cpp_lib_three_way_comparison)
+# if (__cplusplus >= 202002L) && (__cpp_impl_three_way_comparison >= 201907L && __glibcxx_concepts)
+# define __glibcxx_three_way_comparison 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_three_way_comparison)
+# define __cpp_lib_three_way_comparison 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_three_way_comparison) && defined(__glibcxx_want_three_way_comparison) */
+#undef __glibcxx_want_three_way_comparison
+
+// from version.def line 981
+#if !defined(__cpp_lib_to_address)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_to_address 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_address)
+# define __cpp_lib_to_address 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_address) && defined(__glibcxx_want_to_address) */
+#undef __glibcxx_want_to_address
+
+// from version.def line 989
+#if !defined(__cpp_lib_to_array)
+# if (__cplusplus >= 202002L) && (__cpp_generic_lambdas >= 201707L)
+# define __glibcxx_to_array 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_array)
+# define __cpp_lib_to_array 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_array) && defined(__glibcxx_want_to_array) */
+#undef __glibcxx_want_to_array
+
+// from version.def line 998
+#if !defined(__cpp_lib_type_identity)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_type_identity 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_type_identity)
+# define __cpp_lib_type_identity 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_type_identity) && defined(__glibcxx_want_type_identity) */
+#undef __glibcxx_want_type_identity
+
+// from version.def line 1006
+#if !defined(__cpp_lib_unwrap_ref)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_unwrap_ref 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unwrap_ref)
+# define __cpp_lib_unwrap_ref 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_unwrap_ref) && defined(__glibcxx_want_unwrap_ref) */
+#undef __glibcxx_want_unwrap_ref
+
+// from version.def line 1014
+#if !defined(__cpp_lib_constexpr_iterator)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_iterator 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_iterator)
+# define __cpp_lib_constexpr_iterator 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_iterator) && defined(__glibcxx_want_constexpr_iterator) */
+#undef __glibcxx_want_constexpr_iterator
+
+// from version.def line 1022
+#if !defined(__cpp_lib_interpolate)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_interpolate 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_interpolate)
+# define __cpp_lib_interpolate 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_interpolate) && defined(__glibcxx_want_interpolate) */
+#undef __glibcxx_want_interpolate
+
+// from version.def line 1030
+#if !defined(__cpp_lib_constexpr_utility)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_utility 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_utility)
+# define __cpp_lib_constexpr_utility 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_utility) && defined(__glibcxx_want_constexpr_utility) */
+#undef __glibcxx_want_constexpr_utility
+
+// from version.def line 1038
+#if !defined(__cpp_lib_shift)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_shift 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_shift)
+# define __cpp_lib_shift 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_shift) && defined(__glibcxx_want_shift) */
+#undef __glibcxx_want_shift
+
+// from version.def line 1046
+#if !defined(__cpp_lib_ranges)
+# if (__cplusplus > 202002L) && (__glibcxx_concepts)
+# define __glibcxx_ranges 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges)
+# define __cpp_lib_ranges 202202L
+# endif
+# elif (__cplusplus >= 202002L) && (__glibcxx_concepts)
+# define __glibcxx_ranges 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges)
+# define __cpp_lib_ranges 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges) && defined(__glibcxx_want_ranges) */
+#undef __glibcxx_want_ranges
+
+// from version.def line 1060
+#if !defined(__cpp_lib_constexpr_numeric)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_numeric 201911L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_numeric)
+# define __cpp_lib_constexpr_numeric 201911L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_numeric) && defined(__glibcxx_want_constexpr_numeric) */
+#undef __glibcxx_want_constexpr_numeric
+
+// from version.def line 1068
+#if !defined(__cpp_lib_constexpr_functional)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_functional 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_functional)
+# define __cpp_lib_constexpr_functional 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_functional) && defined(__glibcxx_want_constexpr_functional) */
+#undef __glibcxx_want_constexpr_functional
+
+// from version.def line 1076
+#if !defined(__cpp_lib_constexpr_algorithms)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_algorithms 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_algorithms)
+# define __cpp_lib_constexpr_algorithms 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_algorithms) && defined(__glibcxx_want_constexpr_algorithms) */
+#undef __glibcxx_want_constexpr_algorithms
+
+// from version.def line 1084
+#if !defined(__cpp_lib_constexpr_tuple)
+# if (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_tuple 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_tuple)
+# define __cpp_lib_constexpr_tuple 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_tuple) && defined(__glibcxx_want_constexpr_tuple) */
+#undef __glibcxx_want_constexpr_tuple
+
+// from version.def line 1092
+#if !defined(__cpp_lib_constexpr_memory)
+# if (__cplusplus > 202002L) && (__cpp_constexpr_dynamic_alloc)
+# define __glibcxx_constexpr_memory 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_memory)
+# define __cpp_lib_constexpr_memory 202202L
+# endif
+# elif (__cplusplus >= 202002L)
+# define __glibcxx_constexpr_memory 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_memory)
+# define __cpp_lib_constexpr_memory 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_memory) && defined(__glibcxx_want_constexpr_memory) */
+#undef __glibcxx_want_constexpr_memory
+
+// from version.def line 1105
+#if !defined(__cpp_lib_atomic_shared_ptr)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_atomic_shared_ptr 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_shared_ptr)
+# define __cpp_lib_atomic_shared_ptr 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_shared_ptr) && defined(__glibcxx_want_atomic_shared_ptr) */
+#undef __glibcxx_want_atomic_shared_ptr
+
+// from version.def line 1114
+#if !defined(__cpp_lib_atomic_wait)
+# if (__cplusplus >= 202002L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_atomic_wait 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_wait)
+# define __cpp_lib_atomic_wait 201907L
+# endif
+# elif (__cplusplus >= 202002L) && !defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED && (defined(_GLIBCXX_HAVE_LINUX_FUTEX))
+# define __glibcxx_atomic_wait 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_atomic_wait)
+# define __cpp_lib_atomic_wait 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_atomic_wait) && defined(__glibcxx_want_atomic_wait) */
+#undef __glibcxx_want_atomic_wait
+
+// from version.def line 1132
+#if !defined(__cpp_lib_barrier)
+# if (__cplusplus >= 202002L) && (__cpp_aligned_new && __glibcxx_atomic_wait)
+# define __glibcxx_barrier 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_barrier)
+# define __cpp_lib_barrier 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_barrier) && defined(__glibcxx_want_barrier) */
+#undef __glibcxx_want_barrier
+
+// from version.def line 1149
+#if !defined(__cpp_lib_format)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_format 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_format)
+# define __cpp_lib_format 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_format) && defined(__glibcxx_want_format) */
+#undef __glibcxx_want_format
+
+// from version.def line 1162
+#if !defined(__cpp_lib_constexpr_complex)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_constexpr_complex 201711L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_complex)
+# define __cpp_lib_constexpr_complex 201711L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_complex) && defined(__glibcxx_want_constexpr_complex) */
+#undef __glibcxx_want_constexpr_complex
+
+// from version.def line 1171
+#if !defined(__cpp_lib_constexpr_dynamic_alloc)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_constexpr_dynamic_alloc 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_dynamic_alloc)
+# define __cpp_lib_constexpr_dynamic_alloc 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_dynamic_alloc) && defined(__glibcxx_want_constexpr_dynamic_alloc) */
+#undef __glibcxx_want_constexpr_dynamic_alloc
+
+// from version.def line 1180
+#if !defined(__cpp_lib_constexpr_string)
+# if (__cplusplus >= 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED && (defined(__glibcxx_is_constant_evaluated))
+# define __glibcxx_constexpr_string 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string)
+# define __cpp_lib_constexpr_string 201907L
+# endif
+# elif (__cplusplus >= 202002L) && !_GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED && (defined(__glibcxx_is_constant_evaluated))
+# define __glibcxx_constexpr_string 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string)
+# define __cpp_lib_constexpr_string 201811L
+# endif
+# elif (__cplusplus >= 201703L) && _GLIBCXX_HOSTED && (_GLIBCXX_HAVE_IS_CONSTANT_EVALUATED)
+# define __glibcxx_constexpr_string 201611L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_string)
+# define __cpp_lib_constexpr_string 201611L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_string) && defined(__glibcxx_want_constexpr_string) */
+#undef __glibcxx_want_constexpr_string
+
+// from version.def line 1204
+#if !defined(__cpp_lib_constexpr_vector)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_constexpr_vector 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_vector)
+# define __cpp_lib_constexpr_vector 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_vector) && defined(__glibcxx_want_constexpr_vector) */
+#undef __glibcxx_want_constexpr_vector
+
+// from version.def line 1213
+#if !defined(__cpp_lib_erase_if)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_erase_if 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_erase_if)
+# define __cpp_lib_erase_if 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_erase_if) && defined(__glibcxx_want_erase_if) */
+#undef __glibcxx_want_erase_if
+
+// from version.def line 1222
+#if !defined(__cpp_lib_generic_unordered_lookup)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_generic_unordered_lookup 201811L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generic_unordered_lookup)
+# define __cpp_lib_generic_unordered_lookup 201811L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_generic_unordered_lookup) && defined(__glibcxx_want_generic_unordered_lookup) */
+#undef __glibcxx_want_generic_unordered_lookup
+
+// from version.def line 1231
+#if !defined(__cpp_lib_jthread)
+# if (__cplusplus >= 202002L) && defined(_GLIBCXX_HAS_GTHREADS) && _GLIBCXX_HOSTED
+# define __glibcxx_jthread 201911L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_jthread)
+# define __cpp_lib_jthread 201911L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_jthread) && defined(__glibcxx_want_jthread) */
+#undef __glibcxx_want_jthread
+
+// from version.def line 1241
+#if !defined(__cpp_lib_latch)
+# if (__cplusplus >= 202002L) && (__glibcxx_atomic_wait)
+# define __glibcxx_latch 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_latch)
+# define __cpp_lib_latch 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_latch) && defined(__glibcxx_want_latch) */
+#undef __glibcxx_want_latch
+
+// from version.def line 1250
+#if !defined(__cpp_lib_list_remove_return_type)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_list_remove_return_type 201806L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_list_remove_return_type)
+# define __cpp_lib_list_remove_return_type 201806L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_list_remove_return_type) && defined(__glibcxx_want_list_remove_return_type) */
+#undef __glibcxx_want_list_remove_return_type
+
+// from version.def line 1259
+#if !defined(__cpp_lib_polymorphic_allocator)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_polymorphic_allocator 201902L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_polymorphic_allocator)
+# define __cpp_lib_polymorphic_allocator 201902L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_polymorphic_allocator) && defined(__glibcxx_want_polymorphic_allocator) */
+#undef __glibcxx_want_polymorphic_allocator
+
+// from version.def line 1268
+#if !defined(__cpp_lib_move_iterator_concept)
+# if (__cplusplus >= 202002L) && (__glibcxx_concepts)
+# define __glibcxx_move_iterator_concept 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_move_iterator_concept)
+# define __cpp_lib_move_iterator_concept 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_move_iterator_concept) && defined(__glibcxx_want_move_iterator_concept) */
+#undef __glibcxx_want_move_iterator_concept
+
+// from version.def line 1278
+#if !defined(__cpp_lib_semaphore)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED && (__glibcxx_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE)
+# define __glibcxx_semaphore 201907L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_semaphore)
+# define __cpp_lib_semaphore 201907L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_semaphore) && defined(__glibcxx_want_semaphore) */
+#undef __glibcxx_want_semaphore
+
+// from version.def line 1288
+#if !defined(__cpp_lib_smart_ptr_for_overwrite)
+# if (__cplusplus >= 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_smart_ptr_for_overwrite 202002L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_smart_ptr_for_overwrite)
+# define __cpp_lib_smart_ptr_for_overwrite 202002L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_smart_ptr_for_overwrite) && defined(__glibcxx_want_smart_ptr_for_overwrite) */
+#undef __glibcxx_want_smart_ptr_for_overwrite
+
+// from version.def line 1297
+#if !defined(__cpp_lib_syncbuf)
+# if (__cplusplus >= 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED
+# define __glibcxx_syncbuf 201803L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_syncbuf)
+# define __cpp_lib_syncbuf 201803L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_syncbuf) && defined(__glibcxx_want_syncbuf) */
+#undef __glibcxx_want_syncbuf
+
+// from version.def line 1307
+#if !defined(__cpp_lib_byteswap)
+# if (__cplusplus > 202002L)
+# define __glibcxx_byteswap 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_byteswap)
+# define __cpp_lib_byteswap 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_byteswap) && defined(__glibcxx_want_byteswap) */
+#undef __glibcxx_want_byteswap
+
+// from version.def line 1315
+#if !defined(__cpp_lib_constexpr_charconv)
+# if (__cplusplus > 202002L)
+# define __glibcxx_constexpr_charconv 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_charconv)
+# define __cpp_lib_constexpr_charconv 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_charconv) && defined(__glibcxx_want_constexpr_charconv) */
+#undef __glibcxx_want_constexpr_charconv
+
+// from version.def line 1323
+#if !defined(__cpp_lib_constexpr_typeinfo)
+# if (__cplusplus > 202002L)
+# define __glibcxx_constexpr_typeinfo 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_typeinfo)
+# define __cpp_lib_constexpr_typeinfo 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_typeinfo) && defined(__glibcxx_want_constexpr_typeinfo) */
+#undef __glibcxx_want_constexpr_typeinfo
+
+// from version.def line 1331
+#if !defined(__cpp_lib_expected)
+# if (__cplusplus > 202002L) && (__cpp_concepts >= 202002L)
+# define __glibcxx_expected 202211L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_expected)
+# define __cpp_lib_expected 202211L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_expected) && defined(__glibcxx_want_expected) */
+#undef __glibcxx_want_expected
+
+// from version.def line 1340
+#if !defined(__cpp_lib_invoke_r)
+# if (__cplusplus > 202002L)
+# define __glibcxx_invoke_r 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_invoke_r)
+# define __cpp_lib_invoke_r 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_invoke_r) && defined(__glibcxx_want_invoke_r) */
+#undef __glibcxx_want_invoke_r
+
+// from version.def line 1348
+#if !defined(__cpp_lib_is_scoped_enum)
+# if (__cplusplus > 202002L)
+# define __glibcxx_is_scoped_enum 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_is_scoped_enum)
+# define __cpp_lib_is_scoped_enum 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_is_scoped_enum) && defined(__glibcxx_want_is_scoped_enum) */
+#undef __glibcxx_want_is_scoped_enum
+
+// from version.def line 1356
+#if !defined(__cpp_lib_reference_from_temporary)
+# if (__cplusplus > 202002L) && (__has_builtin(__reference_constructs_from_temporary) && __has_builtin(__reference_converts_from_temporary))
+# define __glibcxx_reference_from_temporary 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_reference_from_temporary)
+# define __cpp_lib_reference_from_temporary 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_reference_from_temporary) && defined(__glibcxx_want_reference_from_temporary) */
+#undef __glibcxx_want_reference_from_temporary
+
+// from version.def line 1367
+#if !defined(__cpp_lib_to_underlying)
+# if (__cplusplus > 202002L)
+# define __glibcxx_to_underlying 202102L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_to_underlying)
+# define __cpp_lib_to_underlying 202102L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_to_underlying) && defined(__glibcxx_want_to_underlying) */
+#undef __glibcxx_want_to_underlying
+
+// from version.def line 1375
+#if !defined(__cpp_lib_unreachable)
+# if (__cplusplus > 202002L)
+# define __glibcxx_unreachable 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_unreachable)
+# define __cpp_lib_unreachable 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_unreachable) && defined(__glibcxx_want_unreachable) */
+#undef __glibcxx_want_unreachable
+
+// from version.def line 1383
+#if !defined(__cpp_lib_ranges_zip)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_zip 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_zip)
+# define __cpp_lib_ranges_zip 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_zip) && defined(__glibcxx_want_ranges_zip) */
+#undef __glibcxx_want_ranges_zip
+
+// from version.def line 1391
+#if !defined(__cpp_lib_ranges_chunk)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_chunk 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_chunk)
+# define __cpp_lib_ranges_chunk 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_chunk) && defined(__glibcxx_want_ranges_chunk) */
+#undef __glibcxx_want_ranges_chunk
+
+// from version.def line 1399
+#if !defined(__cpp_lib_ranges_slide)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_slide 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_slide)
+# define __cpp_lib_ranges_slide 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_slide) && defined(__glibcxx_want_ranges_slide) */
+#undef __glibcxx_want_ranges_slide
+
+// from version.def line 1407
+#if !defined(__cpp_lib_ranges_chunk_by)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_chunk_by 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_chunk_by)
+# define __cpp_lib_ranges_chunk_by 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_chunk_by) && defined(__glibcxx_want_ranges_chunk_by) */
+#undef __glibcxx_want_ranges_chunk_by
+
+// from version.def line 1415
+#if !defined(__cpp_lib_ranges_join_with)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_join_with 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_join_with)
+# define __cpp_lib_ranges_join_with 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_join_with) && defined(__glibcxx_want_ranges_join_with) */
+#undef __glibcxx_want_ranges_join_with
+
+// from version.def line 1423
+#if !defined(__cpp_lib_ranges_repeat)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_repeat 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_repeat)
+# define __cpp_lib_ranges_repeat 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_repeat) && defined(__glibcxx_want_ranges_repeat) */
+#undef __glibcxx_want_ranges_repeat
+
+// from version.def line 1431
+#if !defined(__cpp_lib_ranges_stride)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_stride 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_stride)
+# define __cpp_lib_ranges_stride 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_stride) && defined(__glibcxx_want_ranges_stride) */
+#undef __glibcxx_want_ranges_stride
+
+// from version.def line 1439
+#if !defined(__cpp_lib_ranges_cartesian_product)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_cartesian_product 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_cartesian_product)
+# define __cpp_lib_ranges_cartesian_product 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_cartesian_product) && defined(__glibcxx_want_ranges_cartesian_product) */
+#undef __glibcxx_want_ranges_cartesian_product
+
+// from version.def line 1447
+#if !defined(__cpp_lib_ranges_as_rvalue)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_as_rvalue 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_as_rvalue)
+# define __cpp_lib_ranges_as_rvalue 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_as_rvalue) && defined(__glibcxx_want_ranges_as_rvalue) */
+#undef __glibcxx_want_ranges_as_rvalue
+
+// from version.def line 1455
+#if !defined(__cpp_lib_ranges_as_const)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_as_const 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_as_const)
+# define __cpp_lib_ranges_as_const 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_as_const) && defined(__glibcxx_want_ranges_as_const) */
+#undef __glibcxx_want_ranges_as_const
+
+// from version.def line 1463
+#if !defined(__cpp_lib_ranges_enumerate)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_enumerate 202302L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_enumerate)
+# define __cpp_lib_ranges_enumerate 202302L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_enumerate) && defined(__glibcxx_want_ranges_enumerate) */
+#undef __glibcxx_want_ranges_enumerate
+
+// from version.def line 1471
+#if !defined(__cpp_lib_ranges_fold)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_fold 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_fold)
+# define __cpp_lib_ranges_fold 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_fold) && defined(__glibcxx_want_ranges_fold) */
+#undef __glibcxx_want_ranges_fold
+
+// from version.def line 1479
+#if !defined(__cpp_lib_ranges_contains)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_contains 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_contains)
+# define __cpp_lib_ranges_contains 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_contains) && defined(__glibcxx_want_ranges_contains) */
+#undef __glibcxx_want_ranges_contains
+
+// from version.def line 1487
+#if !defined(__cpp_lib_ranges_iota)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_iota 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_iota)
+# define __cpp_lib_ranges_iota 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_iota) && defined(__glibcxx_want_ranges_iota) */
+#undef __glibcxx_want_ranges_iota
+
+// from version.def line 1495
+#if !defined(__cpp_lib_ranges_find_last)
+# if (__cplusplus > 202002L)
+# define __glibcxx_ranges_find_last 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ranges_find_last)
+# define __cpp_lib_ranges_find_last 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ranges_find_last) && defined(__glibcxx_want_ranges_find_last) */
+#undef __glibcxx_want_ranges_find_last
+
+// from version.def line 1503
+#if !defined(__cpp_lib_constexpr_bitset)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (__cpp_constexpr_dynamic_alloc)
+# define __glibcxx_constexpr_bitset 202202L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_constexpr_bitset)
+# define __cpp_lib_constexpr_bitset 202202L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_constexpr_bitset) && defined(__glibcxx_want_constexpr_bitset) */
+#undef __glibcxx_want_constexpr_bitset
+
+// from version.def line 1513
+#if !defined(__cpp_lib_stdatomic_h)
+# if (__cplusplus > 202002L)
+# define __glibcxx_stdatomic_h 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_stdatomic_h)
+# define __cpp_lib_stdatomic_h 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_stdatomic_h) && defined(__glibcxx_want_stdatomic_h) */
+#undef __glibcxx_want_stdatomic_h
+
+// from version.def line 1521
+#if !defined(__cpp_lib_adaptor_iterator_pair_constructor)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_adaptor_iterator_pair_constructor 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_adaptor_iterator_pair_constructor)
+# define __cpp_lib_adaptor_iterator_pair_constructor 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_adaptor_iterator_pair_constructor) && defined(__glibcxx_want_adaptor_iterator_pair_constructor) */
+#undef __glibcxx_want_adaptor_iterator_pair_constructor
+
+// from version.def line 1530
+#if !defined(__cpp_lib_ios_noreplace)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_ios_noreplace 202207L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_ios_noreplace)
+# define __cpp_lib_ios_noreplace 202207L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_ios_noreplace) && defined(__glibcxx_want_ios_noreplace) */
+#undef __glibcxx_want_ios_noreplace
+
+// from version.def line 1539
+#if !defined(__cpp_lib_move_only_function)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_move_only_function 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_move_only_function)
+# define __cpp_lib_move_only_function 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_move_only_function) && defined(__glibcxx_want_move_only_function) */
+#undef __glibcxx_want_move_only_function
+
+// from version.def line 1548
+#if !defined(__cpp_lib_spanstream)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (__glibcxx_span)
+# define __glibcxx_spanstream 202106L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_spanstream)
+# define __cpp_lib_spanstream 202106L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_spanstream) && defined(__glibcxx_want_spanstream) */
+#undef __glibcxx_want_spanstream
+
+// from version.def line 1558
+#if !defined(__cpp_lib_stacktrace)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED && (_GLIBCXX_HAVE_STACKTRACE)
+# define __glibcxx_stacktrace 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_stacktrace)
+# define __cpp_lib_stacktrace 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_stacktrace) && defined(__glibcxx_want_stacktrace) */
+#undef __glibcxx_want_stacktrace
+
+// from version.def line 1568
+#if !defined(__cpp_lib_string_contains)
+# if (__cplusplus > 202002L) && _GLIBCXX_HOSTED
+# define __glibcxx_string_contains 202011L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_contains)
+# define __cpp_lib_string_contains 202011L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_contains) && defined(__glibcxx_want_string_contains) */
+#undef __glibcxx_want_string_contains
+
+// from version.def line 1577
+#if !defined(__cpp_lib_string_resize_and_overwrite)
+# if (__cplusplus > 202002L) && _GLIBCXX_USE_CXX11_ABI && _GLIBCXX_HOSTED
+# define __glibcxx_string_resize_and_overwrite 202110L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_string_resize_and_overwrite)
+# define __cpp_lib_string_resize_and_overwrite 202110L
+# endif
+# endif
+#endif /* !defined(__cpp_lib_string_resize_and_overwrite) && defined(__glibcxx_want_string_resize_and_overwrite) */
+#undef __glibcxx_want_string_resize_and_overwrite
+
+#undef __glibcxx_want_all
diff --git a/libstdc++-v3/include/bits/version.tpl b/libstdc++-v3/include/bits/version.tpl
new file mode 100644
index 000000000000..0b15eed35c3b
--- /dev/null
+++ b/libstdc++-v3/include/bits/version.tpl
@@ -0,0 +1,210 @@
+/*{ AutoGen5 template -*- C++ -*-
+h
+(use-modules (srfi srfi-1))
+}*/
+// Copyright (C) 2023 Free Software Foundation, Inc.
+
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/*{ (dne "// ") }*/
+
+/** @file bits/version.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{version}
+ */
+
+// Usage guide:
+//
+// In your usual header, do something like:
+//
+// #define __glibcxx_want_ranges
+// #define __glibcxx_want_concepts
+// #include <bits/version.h>
+//
+// This will generate the FTMs you named, and let you use them in your code as
+// if it was user code. All macros are also exposed under __glibcxx_NAME even
+// if unwanted, to permit bits and other FTMs to depend on them for condtional
+// computation without exposing extra FTMs to user code.
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+/*{
+
+;; Helper for dealing with autogens redefined (error)
+(define (ferror msg . args)
+ (error (apply format (cons* #f msg args))))
+
+ ;; Helper function that, in the context of a single FTM value, generates the
+;; condition expression that fulfills the specification of this value. See the
+;; comment block in version.def for an explanation of the format this
+;; function parses.
+(define (generate-cond)
+ (define c++min #f)
+ (define gnu++min #f)
+ (define gthread #f)
+ (define hosted #f)
+ (define c++11-abi #f)
+ (define extra-cond (get "extra_cond"))
+
+ (define conds '())
+ (define (prepend x)
+ (if x (set! conds (cons x conds))))
+
+ (if (string-null? extra-cond)
+ (set! extra-cond #f))
+
+ (let ((cxxmin (get "cxxmin"))
+ (gnuxxmin (get "gnuxxmin"))
+ (getstdcond
+ (lambda (var)
+ (let ((ver (get var)))
+ (if (not (string-null? ver))
+ (let ((std-cond (get (format #f "stds[~a]" ver))))
+ (if (string-null? std-cond)
+ (ferror "Standard ~s invalid." ver))
+ std-cond)
+ #f)))))
+ (set! c++min (getstdcond "cxxmin"))
+ (set! gnu++min (getstdcond "gnuxxmin")))
+
+ (let ((process-tristate
+ (lambda (name)
+ (let ((val (get name)))
+ (cond
+ ((equal? val "") #f) ; Don't test
+ ((equal? val "yes") "") ; Test directly
+ ((equal? val "no") "!") ; Invert
+ (else (ferror "Bad ~a value ~a." name val)))))))
+ (set! gthread (process-tristate "gthread"))
+ (set! c++11-abi (process-tristate "cxx11abi"))
+ (set! hosted (process-tristate "hosted")))
+
+ (prepend (if extra-cond (format #f "(~a)" extra-cond) #f))
+ (prepend (if hosted (format #f "~a~a" hosted "_GLIBCXX_HOSTED") #f))
+ (prepend (if gthread (format #f "~a~a" gthread "defined(_GLIBCXX_HAS_GTHREADS)") #f))
+ (prepend (if c++11-abi (format #f "~a~a" c++11-abi "_GLIBCXX_USE_CXX11_ABI") #f))
+
+ (prepend
+ (let ((strict "defined(__STRICT_ANSI__)")
+ (c++ "__cplusplus"))
+ (cond
+ ((or (and (equal? c++min gnu++min) c++min)
+ (and (not gnu++min) c++min))
+ ;; If we have both values, and they are equal, or we only have gnu++min,
+ ;; we want to output a simple check.
+ (format #f "(~a ~a)" c++ c++min))
+ ((and gnu++min c++min)
+ ;; We have differing cases for strict and non-strict modes.
+ (format #f "((~a && ~a ~a) || (!~a && ~a ~a))"
+ strict c++ c++min
+ strict c++ gnu++min))
+ ((and gnu++min (not c++min))
+ (format #f "(!~a && (~a ~a))" strict c++ gnu++min))
+ (else #f))))
+ (string-join conds " && " 'strict-infix))
+
+
+ }*/
+/*{ FOR ftms
+ }*/// /*{ (def-file-line "name") }*/
+#if !defined(__cpp_lib_/*{name}*/)
+/*{ FOR values }*//*{ #
+
+ This macro block defines two versions of each FTM:
+
+ 1. __glibcxx_NAME, which is defined unconditionally, and
+ 2. __cpp_lib_NAME, which is defined only if marked as wanted.
+
+ This allows FTMs to depend on eachother in their definitions without messing
+ with the exported values.
+
+ This can also be used by bits that do not want to expose FTMs that they can't
+ implement.
+
+}*/# /*{(unless (first-for?) "el")}*/if /*{(generate-cond)}*/
+# define __glibcxx_/*{name}*/ /*{v}*/L
+# if defined(__glibcxx_want_all) || defined(__glibcxx_want_/*{name}*/)
+# define /*{
+;; Compute the name for this FTM based on stdname/name.
+(if (exist? "stdname")
+ (get "stdname")
+ (format #f "__cpp_lib_~a" (get "name")))
+}*/ /*{v}*/L
+# endif
+/*{ ENDFOR values
+ }*/# endif
+#endif /* !defined(__cpp_lib_/*{name}*/) && defined(__glibcxx_want_/*{name}*/) */
+#undef __glibcxx_want_/*{name
+}*//*{ (unless (last-for?) "\n\n" "\n")}*/
+/*{ ENDFOR ftms }*//*{
+
+;; Helper that generates [LO, HI].
+(define (closed-int-set lo hi)
+ (iota (+ (- hi lo) 1) lo))
+
+;; Sanity checking for duplicates and for value order.
+(let ((ht (make-hash-table (count "ftms"))))
+ (for-each
+ (lambda (idx)
+ (let ((name (get (format #f "ftms[~a].name" idx))))
+ (if (string-null? name) (ferror "No name for FTM ~a" idx))
+ (let ((cur (cdr (or (hash-get-handle ht name) '(1 . 0)))))
+ (hash-set! ht name (+ cur 1)))))
+ (closed-int-set (low-lim "ftms") (high-lim "ftms")))
+ (if (hash-fold
+ (lambda (name count prior)
+ (if (= 1 count)
+ prior
+ (begin
+ (printf "FTM %s appears %d times.\n" name count)
+ #t)))
+ #f ht)
+ (error "Duplicates found.")))
+
+(define (check-value-order ftm key order)
+ (let ((valmin 999999)) ; TODO(arsen): bump before year 10000
+ (for-each
+ (lambda (vidx)
+ (let* ((sval (get (format #f "values[~a].~a" vidx key)))
+ (val (string->number sval)))
+ (unless (string-null? sval)
+ (unless val (ferror "Bad value in FTM ~a" ftm))
+ (if (order val valmin)
+ (ferror "Found inverted ~s value in FTM ~a: ~a" key ftm sval))
+ (set! valmin val))))
+ (closed-int-set (low-lim "values") (high-lim "values")))))
+
+}*//*{ FOR ftms }*//*{#
+ Check for values that are in ascending order. Because it is generally the
+ case that FTMs increase as the values of tests they probe for do, we check
+ them to prevent simple, silly errors.
+
+ We're iterating in a separate FOR block rather than in pure Guile since, for
+ some reason, high-lim and low-lim do not work with complex names that include
+ periods and indices (whereas exist? and others do).
+}*//*{
+(let ((ftm (get "name")))
+ (check-value-order (get "name") "v" >)
+ (check-value-order (get "name") "cxxmin" >)
+ (check-value-order (get "name") "gnuxxmin" >))
+}*//*{ ENDFOR ftms }*/
+#undef __glibcxx_want_all
diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version
index 5264c8bff34b..4963e4058f6e 100644
--- a/libstdc++-v3/include/std/version
+++ b/libstdc++-v3/include/std/version
@@ -30,353 +30,9 @@
#ifndef _GLIBCXX_VERSION_INCLUDED
#define _GLIBCXX_VERSION_INCLUDED
-// To facilitate testsuite/17_intro/versionconflict.cc
-#ifndef _GLIBCXX_TESTING_SYSHDR
-# pragma GCC system_header
-#endif
+#pragma GCC system_header
-#include <bits/c++config.h>
-
-// c++03
-#if _GLIBCXX_HOSTED
-# define __cpp_lib_incomplete_container_elements 201505L
-#endif
-
-#if !defined(__STRICT_ANSI__)
-// gnu++03
-# define __cpp_lib_uncaught_exceptions 201411L
-#endif
-
-#if __cplusplus >= 201103L
-// c++11
-#define __cpp_lib_allocator_traits_is_always_equal 201411L
-#define __cpp_lib_is_null_pointer 201309L
-#define __cpp_lib_result_of_sfinae 201210L
-
-#if _GLIBCXX_HOSTED
-#if __cplusplus <= 201703L // N.B. updated value in C++20
-# define __cpp_lib_shared_ptr_arrays 201611L
-#endif
-#endif
-
-#if !defined(__STRICT_ANSI__)
-// gnu++11
-# define __cpp_lib_is_swappable 201603L
-# define __cpp_lib_void_t 201411L
-# if _GLIBCXX_HOSTED
-# define __cpp_lib_enable_shared_from_this 201603L
-# endif
-#endif
-
-// For C++11 and later we support ISO/IEC 29124 Mathematical Special Functions
-#define __STDCPP_MATH_SPEC_FUNCS__ 201003L
-
-#if __cplusplus >= 201402L
-// c++14
-#if __cpp_impl_coroutine
-# define __cpp_lib_coroutine 201902L
-#endif
-#define __cpp_lib_exchange_function 201304L
-#define __cpp_lib_integer_sequence 201304L
-#define __cpp_lib_integral_constant_callable 201304L
-#define __cpp_lib_is_final 201402L
-#define __cpp_lib_make_reverse_iterator 201402L
-#ifndef _GLIBCXX_DEBUG // PR libstdc++/70303
-# define __cpp_lib_null_iterators 201304L
-#endif
-#define __cpp_lib_robust_nonmodifying_seq_ops 201304L
-#define __cpp_lib_transformation_trait_aliases 201304L
-#define __cpp_lib_transparent_operators 201510L
-#define __cpp_lib_tuple_element_t 201402L
-#define __cpp_lib_tuples_by_type 201304L
-
-#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64 \
- && __SIZE_WIDTH__ >= 32
-# define __cpp_lib_to_chars 201611L
-#endif
-
-#if _GLIBCXX_HOSTED
-# define __cpp_lib_chrono_udls 201304L
-# define __cpp_lib_complex_udls 201309L
-# define __cpp_lib_generic_associative_lookup 201304L
-# define __cpp_lib_make_unique 201304L
-# define __cpp_lib_quoted_string_io 201304L
-# ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_shared_timed_mutex 201402L
-# endif
-# define __cpp_lib_string_udls 201304L
-#endif
-
-#if __cplusplus >= 201703L
-// c++17
-#define __cpp_lib_addressof_constexpr 201603L
-#define __cpp_lib_any 201606L
-#define __cpp_lib_apply 201603L
-#define __cpp_lib_as_const 201510L
-#define __cpp_lib_atomic_is_always_lock_free 201603L
-#define __cpp_lib_bool_constant 201505L
-#define __cpp_lib_byte 201603L
-#define __cpp_lib_clamp 201603L
-#define __cpp_lib_gcd 201606L
-#define __cpp_lib_gcd_lcm 201606L
-#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
-# define __cpp_lib_has_unique_object_representations 201606L
-#endif
-#ifdef __GCC_DESTRUCTIVE_SIZE
-# define __cpp_lib_hardware_interference_size 201703L
-#endif
-#define __cpp_lib_invoke 201411L
-#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
-# define __cpp_lib_is_aggregate 201703L
-#endif
-#define __cpp_lib_is_invocable 201703L
-#define __cpp_lib_is_swappable 201603L
-#ifdef _GLIBCXX_HAVE_BUILTIN_LAUNDER
-# define __cpp_lib_launder 201606L
-#endif
-#define __cpp_lib_lcm 201606L
-#define __cpp_lib_logical_traits 201510L
-#define __cpp_lib_make_from_tuple 201606L
-#define __cpp_lib_nonmember_container_access 201411L
-#define __cpp_lib_not_fn 201603L
-#if __cplusplus == 201703L // N.B. updated value in C++20
-# define __cpp_lib_optional 201606L
-#endif
-#define __cpp_lib_raw_memory_algorithms 201606L
-#define __cpp_lib_sample 201603L
-#define __cpp_lib_type_trait_variable_templates 201510L
-#define __cpp_lib_uncaught_exceptions 201411L
-#if !(__cpp_concepts >= 202002L && __cpp_constexpr >= 201811L)
-// N.B. updated value in C++20
-# define __cpp_lib_variant 202102L
-#endif
-#define __cpp_lib_void_t 201411L
-#if __cplusplus == 201703L // N.B. updated value in C++20
-# define __cpp_lib_array_constexpr 201803L
-#endif
-#if __cplusplus == 201703L // N.B. updated value in C++20
-# if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-# define __cpp_lib_constexpr_char_traits 201611L
-# define __cpp_lib_constexpr_string 201611L
-# endif
-#endif
-
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_boyer_moore_searcher 201603L
-#define __cpp_lib_chrono 201611L
-#define __cpp_lib_enable_shared_from_this 201603L
-#define __cpp_lib_execution 201902L // FIXME: should be 201603L
-#define __cpp_lib_filesystem 201703L
-#define __cpp_lib_hypot 201603L
-#define __cpp_lib_map_try_emplace 201411L
-#define __cpp_lib_math_special_functions 201603L
-#ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_memory_resource 201603L
-#else
-# define __cpp_lib_memory_resource 1
-#endif
-#define __cpp_lib_node_extract 201606L
-#define __cpp_lib_parallel_algorithm 201603L
-#ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_scoped_lock 201703L
-# define __cpp_lib_shared_mutex 201505L
-#endif
-#define __cpp_lib_shared_ptr_weak_type 201606L
-#define __cpp_lib_string_view 201803L
-#define __cpp_lib_unordered_map_try_emplace 201411L
-#endif
-
-#if __cplusplus >= 202002L
-// c++20
-#define __cpp_lib_assume_aligned 201811L
-#define __cpp_lib_atomic_flag_test 201907L
-#define __cpp_lib_atomic_float 201711L
-#define __cpp_lib_atomic_lock_free_type_aliases 201907L
-#define __cpp_lib_atomic_ref 201806L
-#define __cpp_lib_atomic_value_initialization 201911L
-#define __cpp_lib_bind_front 201907L
-#define __cpp_lib_starts_ends_with 201711L
-#if __has_builtin(__builtin_bit_cast)
-# define __cpp_lib_bit_cast 201806L
-#endif
-#define __cpp_lib_bitops 201907L
-#define __cpp_lib_bounded_array_traits 201902L
-// __cpp_lib_char8_t is defined in <bits/c++config.h>
-#if __cpp_concepts >= 201907L
-# define __cpp_lib_concepts 202002L
-#endif
-#if __cpp_impl_destroying_delete
-# define __cpp_lib_destroying_delete 201806L
-#endif
-#define __cpp_lib_constexpr_string_view 201811L
-#define __cpp_lib_endian 201907L
-#define __cpp_lib_int_pow2 202002L
-#define __cpp_lib_integer_comparison_functions 202002L
-#ifdef _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED
-# define __cpp_lib_is_constant_evaluated 201811L
-#endif
-#if __has_builtin(__is_layout_compatible) \
- && __has_builtin(__builtin_is_corresponding_member)
-# define __cpp_lib_is_layout_compatible 201907L
-#endif
-#define __cpp_lib_is_nothrow_convertible 201806L
-#if __has_builtin(__is_pointer_interconvertible_base_of) \
- && __has_builtin(__builtin_is_pointer_interconvertible_with_class)
-# define __cpp_lib_is_pointer_interconvertible 201907L
-#endif
-#define __cpp_lib_math_constants 201907L
-#if __cpp_lib_concepts
-# define __cpp_lib_make_obj_using_allocator 201811L
-#endif
-#if __cplusplus <= 202002L // N.B. updated value in C++23
-# define __cpp_lib_optional 202106L
-#endif
-#define __cpp_lib_remove_cvref 201711L
-#if __has_builtin(__builtin_source_location)
-# define __cpp_lib_source_location 201907L
-#endif
-#if __cpp_lib_concepts
-# define __cpp_lib_span 202002L
-#endif
-#define __cpp_lib_ssize 201902L
-#if __cpp_impl_three_way_comparison >= 201907L && __cpp_lib_concepts
-# define __cpp_lib_three_way_comparison 201907L
-#endif
-#define __cpp_lib_to_address 201711L
-#define __cpp_lib_to_array 201907L
-#define __cpp_lib_type_identity 201806L
-#define __cpp_lib_unwrap_ref 201811L
-#if __cpp_concepts >= 202002L && __cpp_constexpr >= 201811L
-# define __cpp_lib_variant 202106L
-#endif
-#define __cpp_lib_constexpr_algorithms 201806L
-#define __cpp_lib_constexpr_functional 201907L
-#if __cplusplus <= 202002L // N.B. updated value in C++23
-# define __cpp_lib_constexpr_memory 201811L
-#endif // C++20
-#define __cpp_lib_constexpr_numeric 201911L
-#define __cpp_lib_constexpr_tuple 201811L
-#define __cpp_lib_array_constexpr 201811L
-#ifdef __cpp_lib_is_constant_evaluated
-# define __cpp_lib_constexpr_char_traits 201811L
-#endif
-#define __cpp_lib_constexpr_iterator 201811L
-#define __cpp_lib_constexpr_utility 201811L
-#define __cpp_lib_interpolate 201902L
-#if __cpp_lib_concepts
-# define __cpp_lib_move_iterator_concept 202207L
-#if __cplusplus <= 202002L // N.B. updated value in C++23
-# define __cpp_lib_ranges 202110L
-#endif
-#endif
-#define __cpp_lib_shift 201806L
-
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_atomic_shared_ptr 201711L
-#if defined _GLIBCXX_HAS_GTHREADS || defined _GLIBCXX_HAVE_LINUX_FUTEX
-# define __cpp_lib_atomic_wait 201907L
-# if __cpp_aligned_new
-# define __cpp_lib_barrier 201907L
-# endif
-#endif
-#undef __cpp_lib_chrono
-#define __cpp_lib_chrono 201907L
-// FIXME: #define __cpp_lib_execution 201902L
-#define __cpp_lib_constexpr_complex 201711L
-#define __cpp_lib_constexpr_dynamic_alloc 201907L
-#define __cpp_lib_constexpr_tuple 201811L
-#ifdef __cpp_lib_is_constant_evaluated
-# if _GLIBCXX_USE_CXX11_ABI
-# define __cpp_lib_constexpr_string 201907L
-# else
-# define __cpp_lib_constexpr_string 201811L
-# endif
-#endif
-#define __cpp_lib_constexpr_vector 201907L
-#define __cpp_lib_erase_if 202002L
-#define __cpp_lib_format 202106L
-#define __cpp_lib_generic_unordered_lookup 201811L
-#ifdef _GLIBCXX_HAS_GTHREADS
-# define __cpp_lib_jthread 201911L
-#endif
-#if __cpp_lib_atomic_wait
-# define __cpp_lib_latch 201907L
-#endif
-#define __cpp_lib_list_remove_return_type 201806L
-#define __cpp_lib_polymorphic_allocator 201902L
-#if __cpp_lib_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE
-# define __cpp_lib_semaphore 201907L
-#endif
-#define __cpp_lib_shared_ptr_arrays 201707L
-#define __cpp_lib_smart_ptr_for_overwrite 202002L
-# if _GLIBCXX_USE_CXX11_ABI
-// Only supported with cxx11-abi
-# define __cpp_lib_syncbuf 201803L
-# endif
-#endif
-
-#if __cplusplus > 202002L
-// c++23
-#define __cpp_lib_byteswap 202110L
-#define __cpp_lib_constexpr_charconv 202207L
-#define __cpp_lib_constexpr_typeinfo 202106L
-#if __cpp_concepts >= 202002L
-# define __cpp_lib_expected 202211L
-#endif
-#define __cpp_lib_invoke_r 202106L
-#define __cpp_lib_is_scoped_enum 202011L
-#if __cpp_lib_concepts
-# undef __cpp_lib_optional
-# define __cpp_lib_optional 202110L
-#endif
-#define __cpp_lib_reference_from_temporary 202202L
-#define __cpp_lib_to_underlying 202102L
-#define __cpp_lib_unreachable 202202L
-#define __cpp_lib_ranges 202202L
-#define __cpp_lib_ranges_zip 202110L
-#define __cpp_lib_ranges_chunk 202202L
-#define __cpp_lib_ranges_slide 202202L
-#define __cpp_lib_ranges_chunk_by 202202L
-#define __cpp_lib_ranges_join_with 202202L
-#define __cpp_lib_ranges_repeat 202207L
-#define __cpp_lib_ranges_stride 202207L
-#define __cpp_lib_ranges_cartesian_product 202207L
-#define __cpp_lib_ranges_as_rvalue 202207L
-#define __cpp_lib_ranges_as_const 202207L
-#define __cpp_lib_ranges_enumerate 202302L
-#define __cpp_lib_ranges_contains 202207L
-#define __cpp_lib_ranges_iota 202202L
-#define __cpp_lib_ranges_find_last 202207L
-#define __cpp_lib_ranges_fold 202207L
-#if __cpp_constexpr_dynamic_alloc
-# if _GLIBCXX_HOSTED
-# define __cpp_lib_constexpr_bitset 202202L
-# endif
-# undef __cpp_lib_constexpr_memory
-# define __cpp_lib_constexpr_memory 202202L
-#endif
-#define __cpp_lib_stdatomic_h 202011L
-
-#if _GLIBCXX_HOSTED
-#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
-#define __cpp_lib_ios_noreplace 202207L
-#define __cpp_lib_move_only_function 202110L
-#if __cpp_lib_span
-# define __cpp_lib_spanstream 202106L
-#endif
-#if _GLIBCXX_HAVE_STACKTRACE
-# define __cpp_lib_stacktrace 202011L
-#endif
-#define __cpp_lib_stdatomic_h 202011L
-#define __cpp_lib_string_contains 202011L
-#if _GLIBCXX_USE_CXX11_ABI // Only supported with cxx11-abi
-# define __cpp_lib_string_resize_and_overwrite 202110L
-#endif
-#endif
-#endif // C++23
-#endif // C++20
-#endif // C++17
-#endif // C++14
-#endif // C++11
+#define __glibcxx_want_all
+#include <bits/version.h>
#endif // _GLIBCXX_VERSION_INCLUDED
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2023-08-16 13:17 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-08-16 13:17 [gcc r14-3247] libstdc++: Implement more maintainable <version> header Arsen Arsenović
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).