[include-mapping] Regenerate the mappings from the 20220730 html book.

[hokein]

Thanks!

The changes in C++ mapping are good in general. Most removals are reasonable, my only concern is the removal of std::{begin, end, size, empty, data} (as they are now provided by multiple headers), IMO these are important symbols (no action needed in this patch, I added them back manually as part of the c-compatibility header change https://reviews.llvm.org/D143160).

clang/include/clang/Tooling/Inclusions/CSymbolMap.inc

12 ↗

(On Diff #493873)

We're removing many macros, macros seems to be moved out to a separated page (https://en.cppreference.com/w/c/symbol_index/macro) in the latest cppreference snapshot, there are some more work needed to update this file. Let's postpone it and focus on the C++ symbols in this patch.

[VitaNuo]

Remove the C symbol map from commit.

[VitaNuo]

Sure, removed the C symbol mapping from this patch. Thanks.

[hokein]

Thanks, it looks good.

One remaining suggestion is to merge the StdRemovedSymbolMap.inc to the StdSymbolMap.inc (it doesn't seem to add much value to maintain a separate file for zoombie symbols), I will address it and land the patch for you.

[hokein]

merge zoombie names to StdSymboMap.inc

clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc

 //===-- gen_std.py generated file -------------------------------*- C++ -*-===//
 //
 // Used to build a lookup table (qualified names => include headers) for CPP
 // Standard Library symbols.
 //
 // This file was generated automatically by
 // clang/tools/include-mapping/gen_std.py, DO NOT EDIT!
 //
-// Generated from cppreference offline HTML book (modified on 2018-10-28).
+// Generated from cppreference offline HTML book (modified on 2022-07-30).
 //===----------------------------------------------------------------------===//
 
-SYMBOL(Assignable, std::, <concepts>)
-SYMBOL(Boolean, std::, <concepts>)
-SYMBOL(Common, std::, <concepts>)
-SYMBOL(CommonReference, std::, <concepts>)
-SYMBOL(Constructible, std::, <concepts>)
-SYMBOL(ConvertibleTo, std::, <concepts>)
-SYMBOL(CopyConstructible, std::, <concepts>)
-SYMBOL(Copyable, std::, <concepts>)
-SYMBOL(DefaultConstructible, std::, <concepts>)
-SYMBOL(DerivedFrom, std::, <concepts>)
-SYMBOL(Destructible, std::, <concepts>)
-SYMBOL(EqualityComparable, std::, <concepts>)
-SYMBOL(EqualityComparableWith, std::, <concepts>)
 SYMBOL(FILE, std::, <cstdio>)
-SYMBOL(Integral, std::, <concepts>)
-SYMBOL(Invocable, std::, <concepts>)
-SYMBOL(Movable, std::, <concepts>)
-SYMBOL(MoveConstructible, std::, <concepts>)
-SYMBOL(Predicate, std::, <concepts>)
-SYMBOL(Regular, std::, <concepts>)
-SYMBOL(RegularInvocable, std::, <concepts>)
-SYMBOL(Relation, std::, <concepts>)
-SYMBOL(Same, std::, <concepts>)
-SYMBOL(Semiregular, std::, <concepts>)
-SYMBOL(SignedIntegral, std::, <concepts>)
-SYMBOL(StrictTotallyOrdered, std::, <concepts>)
-SYMBOL(StrictTotallyOrderedWith, std::, <concepts>)
-SYMBOL(StrictWeakOrder, std::, <concepts>)
-SYMBOL(Swappable, std::, <concepts>)
-SYMBOL(SwappableWith, std::, <concepts>)
-SYMBOL(UniformRandomBitGenerator, std::, <random>)
-SYMBOL(UnsignedIntegral, std::, <concepts>)
 SYMBOL(_Exit, std::, <cstdlib>)
 SYMBOL(accumulate, std::, <numeric>)
 SYMBOL(acos, std::, <cmath>)
+SYMBOL(acosf, std::, <cmath>)
 SYMBOL(acosh, std::, <cmath>)
+SYMBOL(acoshf, std::, <cmath>)
+SYMBOL(acoshl, std::, <cmath>)
+SYMBOL(acosl, std::, <cmath>)
 SYMBOL(add_const, std::, <type_traits>)
 SYMBOL(add_const_t, std::, <type_traits>)
 SYMBOL(add_cv, std::, <type_traits>)
 SYMBOL(add_cv_t, std::, <type_traits>)
 SYMBOL(add_lvalue_reference, std::, <type_traits>)
 SYMBOL(add_lvalue_reference_t, std::, <type_traits>)
 SYMBOL(add_pointer, std::, <type_traits>)
 SYMBOL(add_pointer_t, std::, <type_traits>)

 SYMBOL(aligned_alloc, std::, <cstdlib>)
 SYMBOL(aligned_storage, std::, <type_traits>)
 SYMBOL(aligned_storage_t, std::, <type_traits>)
 SYMBOL(aligned_union, std::, <type_traits>)
 SYMBOL(aligned_union_t, std::, <type_traits>)
 SYMBOL(alignment_of, std::, <type_traits>)
 SYMBOL(alignment_of_v, std::, <type_traits>)
 SYMBOL(all_of, std::, <algorithm>)
+SYMBOL(allocate_at_least, std::, <memory>)
 SYMBOL(allocate_shared, std::, <memory>)
+SYMBOL(allocate_shared_for_overwrite, std::, <memory>)
+SYMBOL(allocation_result, std::, <memory>)
 SYMBOL(allocator, std::, <memory>)
 SYMBOL(allocator_arg, std::, <memory>)
 SYMBOL(allocator_arg_t, std::, <memory>)
 SYMBOL(allocator_traits, std::, <memory>)
 SYMBOL(any, std::, <any>)
 SYMBOL(any_of, std::, <algorithm>)
 SYMBOL(apply, std::, <tuple>)
 SYMBOL(arg, std::, <complex>)
 SYMBOL(array, std::, <array>)
+SYMBOL(as_bytes, std::, <span>)
 SYMBOL(as_const, std::, <utility>)
+SYMBOL(as_writable_bytes, std::, <span>)
 SYMBOL(asctime, std::, <ctime>)
 SYMBOL(asin, std::, <cmath>)
+SYMBOL(asinf, std::, <cmath>)
 SYMBOL(asinh, std::, <cmath>)
+SYMBOL(asinhf, std::, <cmath>)
+SYMBOL(asinhl, std::, <cmath>)
+SYMBOL(asinl, std::, <cmath>)
+SYMBOL(assignable_from, std::, <concepts>)
+SYMBOL(assoc_laguerre, std::, <cmath>)
+SYMBOL(assoc_laguerref, std::, <cmath>)
+SYMBOL(assoc_laguerrel, std::, <cmath>)
+SYMBOL(assoc_legendre, std::, <cmath>)
+SYMBOL(assoc_legendref, std::, <cmath>)
+SYMBOL(assoc_legendrel, std::, <cmath>)
+SYMBOL(assume_aligned, std::, <memory>)
 SYMBOL(async, std::, <future>)
 SYMBOL(at_quick_exit, std::, <cstdlib>)
 SYMBOL(atan, std::, <cmath>)
 SYMBOL(atan2, std::, <cmath>)
+SYMBOL(atan2f, std::, <cmath>)
+SYMBOL(atan2l, std::, <cmath>)
+SYMBOL(atanf, std::, <cmath>)
 SYMBOL(atanh, std::, <cmath>)
+SYMBOL(atanhf, std::, <cmath>)
+SYMBOL(atanhl, std::, <cmath>)
+SYMBOL(atanl, std::, <cmath>)
 SYMBOL(atexit, std::, <cstdlib>)
 SYMBOL(atof, std::, <cstdlib>)
 SYMBOL(atoi, std::, <cstdlib>)
 SYMBOL(atol, std::, <cstdlib>)
 SYMBOL(atoll, std::, <cstdlib>)
 SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
 SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
 SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
 SYMBOL(atomic_compare_exchange_weak_explicit, std::, <atomic>)
 SYMBOL(atomic_exchange, std::, <atomic>)
 SYMBOL(atomic_exchange_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_add, std::, <atomic>)
 SYMBOL(atomic_fetch_add_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_and, std::, <atomic>)
 SYMBOL(atomic_fetch_and_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_or, std::, <atomic>)
 SYMBOL(atomic_fetch_or_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_sub, std::, <atomic>)
 SYMBOL(atomic_fetch_sub_explicit, std::, <atomic>)
 SYMBOL(atomic_fetch_xor, std::, <atomic>)
 SYMBOL(atomic_fetch_xor_explicit, std::, <atomic>)
 SYMBOL(atomic_flag, std::, <atomic>)
 SYMBOL(atomic_flag_clear, std::, <atomic>)
 SYMBOL(atomic_flag_clear_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_notify_all, std::, <atomic>)
+SYMBOL(atomic_flag_notify_one, std::, <atomic>)
+SYMBOL(atomic_flag_test, std::, <atomic>)
 SYMBOL(atomic_flag_test_and_set, std::, <atomic>)
 SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_test_explicit, std::, <atomic>)
+SYMBOL(atomic_flag_wait, std::, <atomic>)
+SYMBOL(atomic_flag_wait_explicit, std::, <atomic>)
 SYMBOL(atomic_init, std::, <atomic>)
-SYMBOL(atomic_is_lockfree, std::, <atomic>)
+SYMBOL(atomic_is_lock_free, std::, <atomic>)
 SYMBOL(atomic_load, std::, <atomic>)
 SYMBOL(atomic_load_explicit, std::, <atomic>)
+SYMBOL(atomic_notify_all, std::, <atomic>)
+SYMBOL(atomic_notify_one, std::, <atomic>)
 SYMBOL(atomic_ref, std::, <atomic>)
 SYMBOL(atomic_signal_fence, std::, <atomic>)
 SYMBOL(atomic_store, std::, <atomic>)
 SYMBOL(atomic_store_explicit, std::, <atomic>)
 SYMBOL(atomic_thread_fence, std::, <atomic>)
+SYMBOL(atomic_wait, std::, <atomic>)
+SYMBOL(atomic_wait_explicit, std::, <atomic>)
 SYMBOL(atto, std::, <ratio>)
 SYMBOL(auto_ptr, std::, <memory>)
 SYMBOL(back_insert_iterator, std::, <iterator>)
 SYMBOL(back_inserter, std::, <iterator>)
 SYMBOL(bad_alloc, std::, <new>)
 SYMBOL(bad_any_cast, std::, <any>)
 SYMBOL(bad_array_new_length, std::, <new>)
 SYMBOL(bad_cast, std::, <typeinfo>)
 SYMBOL(bad_exception, std::, <exception>)
 SYMBOL(bad_function_call, std::, <functional>)
 SYMBOL(bad_optional_access, std::, <optional>)
 SYMBOL(bad_typeid, std::, <typeinfo>)
 SYMBOL(bad_variant_access, std::, <variant>)
 SYMBOL(bad_weak_ptr, std::, <memory>)
+SYMBOL(barrier, std::, <barrier>)
 SYMBOL(basic_common_reference, std::, <type_traits>)
 SYMBOL(basic_filebuf, std::, <fstream>)
 SYMBOL(basic_filebuf, std::, <iosfwd>)
+SYMBOL(basic_format_arg, std::, <format>)
+SYMBOL(basic_format_args, std::, <format>)
+SYMBOL(basic_format_context, std::, <format>)
+SYMBOL(basic_format_parse_context, std::, <format>)
 SYMBOL(basic_fstream, std::, <fstream>)
 SYMBOL(basic_fstream, std::, <iosfwd>)
 SYMBOL(basic_ifstream, std::, <fstream>)
 SYMBOL(basic_ifstream, std::, <iosfwd>)
 SYMBOL(basic_ios, std::, <ios>)
 SYMBOL(basic_ios, std::, <iostream>)
 SYMBOL(basic_ios, std::, <iosfwd>)
 SYMBOL(basic_iostream, std::, <istream>)
 SYMBOL(basic_iostream, std::, <iostream>)
 SYMBOL(basic_iostream, std::, <iosfwd>)
+SYMBOL(basic_ispanstream, std::, <spanstream>)
+SYMBOL(basic_ispanstream, std::, <iosfwd>)
 SYMBOL(basic_istream, std::, <istream>)
 SYMBOL(basic_istream, std::, <iostream>)
 SYMBOL(basic_istream, std::, <iosfwd>)
 SYMBOL(basic_istringstream, std::, <sstream>)
 SYMBOL(basic_istringstream, std::, <iosfwd>)
 SYMBOL(basic_ofstream, std::, <fstream>)
 SYMBOL(basic_ofstream, std::, <iosfwd>)
+SYMBOL(basic_ospanstream, std::, <spanstream>)
+SYMBOL(basic_ospanstream, std::, <iosfwd>)
 SYMBOL(basic_ostream, std::, <ostream>)
 SYMBOL(basic_ostream, std::, <iostream>)
 SYMBOL(basic_ostream, std::, <iosfwd>)
 SYMBOL(basic_ostringstream, std::, <sstream>)
 SYMBOL(basic_ostringstream, std::, <iosfwd>)
 SYMBOL(basic_osyncstream, std::, <syncstream>)
 SYMBOL(basic_osyncstream, std::, <iosfwd>)
 SYMBOL(basic_regex, std::, <regex>)
+SYMBOL(basic_spanbuf, std::, <spanstream>)
+SYMBOL(basic_spanbuf, std::, <iosfwd>)
+SYMBOL(basic_spanstream, std::, <spanstream>)
+SYMBOL(basic_spanstream, std::, <iosfwd>)
+SYMBOL(basic_stacktrace, std::, <stacktrace>)
 SYMBOL(basic_streambuf, std::, <streambuf>)
 SYMBOL(basic_streambuf, std::, <iostream>)
 SYMBOL(basic_streambuf, std::, <iosfwd>)
 SYMBOL(basic_string, std::, <string>)
 SYMBOL(basic_string_view, std::, <string_view>)
 SYMBOL(basic_stringbuf, std::, <sstream>)
 SYMBOL(basic_stringbuf, std::, <iosfwd>)
 SYMBOL(basic_stringstream, std::, <sstream>)
 SYMBOL(basic_stringstream, std::, <iosfwd>)
 SYMBOL(basic_syncbuf, std::, <syncstream>)
 SYMBOL(basic_syncbuf, std::, <iosfwd>)
-SYMBOL(begin, std::, <iterator>)
 SYMBOL(bernoulli_distribution, std::, <random>)
+SYMBOL(beta, std::, <cmath>)
+SYMBOL(betaf, std::, <cmath>)
+SYMBOL(betal, std::, <cmath>)
+SYMBOL(bidirectional_iterator, std::, <iterator>)
 SYMBOL(bidirectional_iterator_tag, std::, <iterator>)
+SYMBOL(binary_function, std::, <functional>)
+SYMBOL(binary_negate, std::, <functional>)
 SYMBOL(binary_search, std::, <algorithm>)
+SYMBOL(binary_semaphore, std::, <semaphore>)
 SYMBOL(bind, std::, <functional>)
+SYMBOL(bind1st, std::, <functional>)
+SYMBOL(bind2nd, std::, <functional>)
+SYMBOL(bind_back, std::, <functional>)
+SYMBOL(bind_front, std::, <functional>)
+SYMBOL(binder1st, std::, <functional>)
+SYMBOL(binder2nd, std::, <functional>)
 SYMBOL(binomial_distribution, std::, <random>)
 SYMBOL(bit_and, std::, <functional>)
 SYMBOL(bit_cast, std::, <bit>)
+SYMBOL(bit_ceil, std::, <bit>)
+SYMBOL(bit_floor, std::, <bit>)
 SYMBOL(bit_not, std::, <functional>)
 SYMBOL(bit_or, std::, <functional>)
+SYMBOL(bit_width, std::, <bit>)
 SYMBOL(bit_xor, std::, <functional>)
 SYMBOL(bitset, std::, <bitset>)
 SYMBOL(bool_constant, std::, <type_traits>)
 SYMBOL(boolalpha, std::, <ios>)
 SYMBOL(boolalpha, std::, <iostream>)
 SYMBOL(boyer_moore_horspool_searcher, std::, <functional>)
 SYMBOL(boyer_moore_searcher, std::, <functional>)
 SYMBOL(bsearch, std::, <cstdlib>)
 SYMBOL(btowc, std::, <cwchar>)
 SYMBOL(byte, std::, <cstddef>)
+SYMBOL(byteswap, std::, <bit>)
 SYMBOL(c16rtomb, std::, <cuchar>)
 SYMBOL(c32rtomb, std::, <cuchar>)
+SYMBOL(c8rtomb, std::, <cuchar>)
 SYMBOL(call_once, std::, <mutex>)
 SYMBOL(calloc, std::, <cstdlib>)
 SYMBOL(cauchy_distribution, std::, <random>)
-SYMBOL(cbegin, std::, <iterator>)
 SYMBOL(cbrt, std::, <cmath>)
+SYMBOL(cbrtf, std::, <cmath>)
+SYMBOL(cbrtl, std::, <cmath>)
 SYMBOL(ceil, std::, <cmath>)
-SYMBOL(ceil2, std::, <bit>)
-SYMBOL(cend, std::, <iterator>)
+SYMBOL(ceilf, std::, <cmath>)
+SYMBOL(ceill, std::, <cmath>)
 SYMBOL(centi, std::, <ratio>)
 SYMBOL(cerr, std::, <iostream>)
 SYMBOL(char_traits, std::, <string>)
 SYMBOL(chars_format, std::, <charconv>)
 SYMBOL(chi_squared_distribution, std::, <random>)
 SYMBOL(cin, std::, <iostream>)
 SYMBOL(clamp, std::, <algorithm>)
 SYMBOL(clearerr, std::, <cstdio>)
 SYMBOL(clock, std::, <ctime>)
 SYMBOL(clock_t, std::, <ctime>)
 SYMBOL(clog, std::, <iostream>)
 SYMBOL(cmatch, std::, <regex>)
+SYMBOL(cmp_equal, std::, <utility>)
+SYMBOL(cmp_greater, std::, <utility>)
+SYMBOL(cmp_greater_equal, std::, <utility>)
+SYMBOL(cmp_less, std::, <utility>)
+SYMBOL(cmp_less_equal, std::, <utility>)
+SYMBOL(cmp_not_equal, std::, <utility>)
 SYMBOL(codecvt, std::, <locale>)
 SYMBOL(codecvt_base, std::, <locale>)
 SYMBOL(codecvt_byname, std::, <locale>)
 SYMBOL(codecvt_mode, std::, <codecvt>)
 SYMBOL(codecvt_utf16, std::, <codecvt>)
 SYMBOL(codecvt_utf8, std::, <codecvt>)
 SYMBOL(codecvt_utf8_utf16, std::, <codecvt>)
 SYMBOL(collate, std::, <locale>)
 SYMBOL(collate_byname, std::, <locale>)
 SYMBOL(common_comparison_category, std::, <compare>)
 SYMBOL(common_comparison_category_t, std::, <compare>)
+SYMBOL(common_iterator, std::, <iterator>)
 SYMBOL(common_reference, std::, <type_traits>)
 SYMBOL(common_reference_t, std::, <type_traits>)
+SYMBOL(common_reference_with, std::, <concepts>)
 SYMBOL(common_type, std::, <type_traits>)
 SYMBOL(common_type_t, std::, <type_traits>)
-SYMBOL(compare_3way, std::, <algorithm>)
+SYMBOL(common_with, std::, <concepts>)
+SYMBOL(comp_ellint_1, std::, <cmath>)
+SYMBOL(comp_ellint_1f, std::, <cmath>)
+SYMBOL(comp_ellint_1l, std::, <cmath>)
+SYMBOL(comp_ellint_2, std::, <cmath>)
+SYMBOL(comp_ellint_2f, std::, <cmath>)
+SYMBOL(comp_ellint_2l, std::, <cmath>)
+SYMBOL(comp_ellint_3, std::, <cmath>)
+SYMBOL(comp_ellint_3f, std::, <cmath>)
+SYMBOL(comp_ellint_3l, std::, <cmath>)
+SYMBOL(compare_partial_order_fallback, std::, <compare>)
+SYMBOL(compare_strong_order_fallback, std::, <compare>)
+SYMBOL(compare_three_way_result, std::, <compare>)
+SYMBOL(compare_three_way_result_t, std::, <compare>)
+SYMBOL(compare_weak_order_fallback, std::, <compare>)
 SYMBOL(complex, std::, <complex>)
 SYMBOL(condition_variable, std::, <condition_variable>)
 SYMBOL(condition_variable_any, std::, <condition_variable>)
 SYMBOL(conditional, std::, <type_traits>)
 SYMBOL(conditional_t, std::, <type_traits>)
 SYMBOL(conj, std::, <complex>)
 SYMBOL(conjunction, std::, <type_traits>)
 SYMBOL(conjunction_v, std::, <type_traits>)
+SYMBOL(const_mem_fun1_ref_t, std::, <functional>)
+SYMBOL(const_mem_fun1_t, std::, <functional>)
+SYMBOL(const_mem_fun_ref_t, std::, <functional>)
+SYMBOL(const_mem_fun_t, std::, <functional>)
 SYMBOL(const_pointer_cast, std::, <memory>)
-SYMBOL(contract_violation, std::, <contract>)
+SYMBOL(construct_at, std::, <memory>)
+SYMBOL(constructible_from, std::, <concepts>)
+SYMBOL(contiguous_iterator, std::, <iterator>)
+SYMBOL(contiguous_iterator_tag, std::, <iterator>)
+SYMBOL(convertible_to, std::, <concepts>)
 SYMBOL(copy, std::, <algorithm>)
 SYMBOL(copy_backward, std::, <algorithm>)
+SYMBOL(copy_constructible, std::, <concepts>)
 SYMBOL(copy_if, std::, <algorithm>)
 SYMBOL(copy_n, std::, <algorithm>)
+SYMBOL(copyable, std::, <concepts>)
 SYMBOL(copysign, std::, <cmath>)
+SYMBOL(copysignf, std::, <cmath>)
+SYMBOL(copysignl, std::, <cmath>)
+SYMBOL(coroutine_handle, std::, <coroutine>)
+SYMBOL(coroutine_traits, std::, <coroutine>)
 SYMBOL(cos, std::, <cmath>)
+SYMBOL(cosf, std::, <cmath>)
 SYMBOL(cosh, std::, <cmath>)
+SYMBOL(coshf, std::, <cmath>)
+SYMBOL(coshl, std::, <cmath>)
+SYMBOL(cosl, std::, <cmath>)
 SYMBOL(count, std::, <algorithm>)
 SYMBOL(count_if, std::, <algorithm>)
+SYMBOL(counted_iterator, std::, <iterator>)
+SYMBOL(counting_semaphore, std::, <semaphore>)
+SYMBOL(countl_one, std::, <bit>)
+SYMBOL(countl_zero, std::, <bit>)
+SYMBOL(countr_one, std::, <bit>)
+SYMBOL(countr_zero, std::, <bit>)
 SYMBOL(cout, std::, <iostream>)
-SYMBOL(crbegin, std::, <iterator>)
 SYMBOL(cref, std::, <functional>)
 SYMBOL(cregex_iterator, std::, <regex>)
 SYMBOL(cregex_token_iterator, std::, <regex>)
-SYMBOL(crend, std::, <iterator>)
 SYMBOL(csub_match, std::, <regex>)
 SYMBOL(ctime, std::, <ctime>)
 SYMBOL(ctype, std::, <locale>)
 SYMBOL(ctype_base, std::, <locale>)
 SYMBOL(ctype_byname, std::, <locale>)
 SYMBOL(current_exception, std::, <exception>)
 SYMBOL(cv_status, std::, <condition_variable>)
-SYMBOL(data, std::, <iterator>)
+SYMBOL(cyl_bessel_i, std::, <cmath>)
+SYMBOL(cyl_bessel_if, std::, <cmath>)
+SYMBOL(cyl_bessel_il, std::, <cmath>)
+SYMBOL(cyl_bessel_j, std::, <cmath>)
+SYMBOL(cyl_bessel_jf, std::, <cmath>)
+SYMBOL(cyl_bessel_jl, std::, <cmath>)
+SYMBOL(cyl_bessel_k, std::, <cmath>)
+SYMBOL(cyl_bessel_kf, std::, <cmath>)
+SYMBOL(cyl_bessel_kl, std::, <cmath>)
+SYMBOL(cyl_neumann, std::, <cmath>)
+SYMBOL(cyl_neumannf, std::, <cmath>)
+SYMBOL(cyl_neumannl, std::, <cmath>)
 SYMBOL(dec, std::, <ios>)
 SYMBOL(dec, std::, <iostream>)
 SYMBOL(deca, std::, <ratio>)
 SYMBOL(decay, std::, <type_traits>)
 SYMBOL(decay_t, std::, <type_traits>)
 SYMBOL(deci, std::, <ratio>)
 SYMBOL(declare_no_pointers, std::, <memory>)
 SYMBOL(declare_reachable, std::, <memory>)
 SYMBOL(declval, std::, <utility>)
 SYMBOL(default_delete, std::, <memory>)
+SYMBOL(default_initializable, std::, <concepts>)
 SYMBOL(default_random_engine, std::, <random>)
 SYMBOL(default_searcher, std::, <functional>)
+SYMBOL(default_sentinel, std::, <iterator>)
+SYMBOL(default_sentinel_t, std::, <iterator>)
 SYMBOL(defaultfloat, std::, <ios>)
 SYMBOL(defaultfloat, std::, <iostream>)
 SYMBOL(defer_lock, std::, <mutex>)
 SYMBOL(defer_lock_t, std::, <mutex>)
 SYMBOL(denorm_absent, std::, <limits>)
 SYMBOL(denorm_indeterminate, std::, <limits>)
 SYMBOL(denorm_present, std::, <limits>)
 SYMBOL(deque, std::, <deque>)
+SYMBOL(derived_from, std::, <concepts>)
 SYMBOL(destroy, std::, <memory>)
 SYMBOL(destroy_at, std::, <memory>)
 SYMBOL(destroy_n, std::, <memory>)
 SYMBOL(destroying_delete, std::, <new>)
 SYMBOL(destroying_delete_t, std::, <new>)
+SYMBOL(destructible, std::, <concepts>)
 SYMBOL(difftime, std::, <ctime>)
+SYMBOL(disable_sized_sentinel_for, std::, <iterator>)
 SYMBOL(discard_block_engine, std::, <random>)
 SYMBOL(discrete_distribution, std::, <random>)
 SYMBOL(disjunction, std::, <type_traits>)
 SYMBOL(disjunction_v, std::, <type_traits>)
 SYMBOL(distance, std::, <iterator>)
 SYMBOL(div_t, std::, <cstdlib>)
 SYMBOL(divides, std::, <functional>)
 SYMBOL(domain_error, std::, <stdexcept>)
 SYMBOL(double_t, std::, <cmath>)
 SYMBOL(dynamic_extent, std::, <span>)
 SYMBOL(dynamic_pointer_cast, std::, <memory>)
+SYMBOL(ellint_1, std::, <cmath>)
+SYMBOL(ellint_1f, std::, <cmath>)
+SYMBOL(ellint_1l, std::, <cmath>)
+SYMBOL(ellint_2, std::, <cmath>)
+SYMBOL(ellint_2f, std::, <cmath>)
+SYMBOL(ellint_2l, std::, <cmath>)
+SYMBOL(ellint_3, std::, <cmath>)
+SYMBOL(ellint_3f, std::, <cmath>)
+SYMBOL(ellint_3l, std::, <cmath>)
 SYMBOL(emit_on_flush, std::, <ostream>)
 SYMBOL(emit_on_flush, std::, <iostream>)
-SYMBOL(empty, std::, <iterator>)
 SYMBOL(enable_if, std::, <type_traits>)
 SYMBOL(enable_if_t, std::, <type_traits>)
 SYMBOL(enable_shared_from_this, std::, <memory>)
-SYMBOL(end, std::, <iterator>)
-SYMBOL(endian, std::, <type_traits>)
+SYMBOL(endian, std::, <bit>)
 SYMBOL(endl, std::, <ostream>)
 SYMBOL(endl, std::, <iostream>)
 SYMBOL(ends, std::, <ostream>)
 SYMBOL(ends, std::, <iostream>)
 SYMBOL(equal, std::, <algorithm>)
 SYMBOL(equal_range, std::, <algorithm>)
 SYMBOL(equal_to, std::, <functional>)
+SYMBOL(equality_comparable, std::, <concepts>)
+SYMBOL(equality_comparable_with, std::, <concepts>)
+SYMBOL(equivalence_relation, std::, <concepts>)
+SYMBOL(erase, std::, <vector>)
+SYMBOL(erase_if, std::, <vector>)
 SYMBOL(erf, std::, <cmath>)
 SYMBOL(erfc, std::, <cmath>)
+SYMBOL(erfcf, std::, <cmath>)
+SYMBOL(erfcl, std::, <cmath>)
+SYMBOL(erff, std::, <cmath>)
+SYMBOL(erfl, std::, <cmath>)
 SYMBOL(errc, std::, <system_error>)
 SYMBOL(error_category, std::, <system_error>)
 SYMBOL(error_code, std::, <system_error>)
 SYMBOL(error_condition, std::, <system_error>)
 SYMBOL(exa, std::, <ratio>)
 SYMBOL(exception, std::, <exception>)
 SYMBOL(exception_ptr, std::, <exception>)
 SYMBOL(exchange, std::, <utility>)
 SYMBOL(exclusive_scan, std::, <numeric>)
 SYMBOL(exit, std::, <cstdlib>)
 SYMBOL(exp, std::, <cmath>)
 SYMBOL(exp2, std::, <cmath>)
+SYMBOL(exp2f, std::, <cmath>)
+SYMBOL(exp2l, std::, <cmath>)
+SYMBOL(expf, std::, <cmath>)
+SYMBOL(expint, std::, <cmath>)
+SYMBOL(expintf, std::, <cmath>)
+SYMBOL(expintl, std::, <cmath>)
+SYMBOL(expl, std::, <cmath>)
 SYMBOL(expm1, std::, <cmath>)
+SYMBOL(expm1f, std::, <cmath>)
+SYMBOL(expm1l, std::, <cmath>)
 SYMBOL(exponential_distribution, std::, <random>)
 SYMBOL(extent, std::, <type_traits>)
 SYMBOL(extent_v, std::, <type_traits>)
 SYMBOL(extreme_value_distribution, std::, <random>)
+SYMBOL(fabs, std::, <cmath>)
+SYMBOL(fabsf, std::, <cmath>)
+SYMBOL(fabsl, std::, <cmath>)
 SYMBOL(false_type, std::, <type_traits>)
 SYMBOL(fclose, std::, <cstdio>)
 SYMBOL(fdim, std::, <cmath>)
+SYMBOL(fdimf, std::, <cmath>)
+SYMBOL(fdiml, std::, <cmath>)
 SYMBOL(feclearexcept, std::, <cfenv>)
 SYMBOL(fegetenv, std::, <cfenv>)
 SYMBOL(fegetexceptflag, std::, <cfenv>)
 SYMBOL(fegetround, std::, <cfenv>)
 SYMBOL(feholdexcept, std::, <cfenv>)
 SYMBOL(femto, std::, <ratio>)
 SYMBOL(fenv_t, std::, <cfenv>)
 SYMBOL(feof, std::, <cstdio>)

 SYMBOL(find_if, std::, <algorithm>)
 SYMBOL(find_if_not, std::, <algorithm>)
 SYMBOL(fisher_f_distribution, std::, <random>)
 SYMBOL(fixed, std::, <ios>)
 SYMBOL(fixed, std::, <iostream>)
 SYMBOL(float_denorm_style, std::, <limits>)
 SYMBOL(float_round_style, std::, <limits>)
 SYMBOL(float_t, std::, <cmath>)
+SYMBOL(floating_point, std::, <concepts>)
 SYMBOL(floor, std::, <cmath>)
-SYMBOL(floor2, std::, <bit>)
+SYMBOL(floorf, std::, <cmath>)
+SYMBOL(floorl, std::, <cmath>)
 SYMBOL(flush, std::, <ostream>)
 SYMBOL(flush, std::, <iostream>)
 SYMBOL(flush_emit, std::, <ostream>)
 SYMBOL(flush_emit, std::, <iostream>)
 SYMBOL(fma, std::, <cmath>)
+SYMBOL(fmaf, std::, <cmath>)
+SYMBOL(fmal, std::, <cmath>)
 SYMBOL(fmax, std::, <cmath>)
+SYMBOL(fmaxf, std::, <cmath>)
+SYMBOL(fmaxl, std::, <cmath>)
 SYMBOL(fmin, std::, <cmath>)
+SYMBOL(fminf, std::, <cmath>)
+SYMBOL(fminl, std::, <cmath>)
 SYMBOL(fmod, std::, <cmath>)
+SYMBOL(fmodf, std::, <cmath>)
+SYMBOL(fmodl, std::, <cmath>)
 SYMBOL(fopen, std::, <cstdio>)
 SYMBOL(for_each, std::, <algorithm>)
 SYMBOL(for_each_n, std::, <algorithm>)
+SYMBOL(format, std::, <format>)
+SYMBOL(format_args, std::, <format>)
+SYMBOL(format_context, std::, <format>)
+SYMBOL(format_error, std::, <format>)
+SYMBOL(format_parse_context, std::, <format>)
+SYMBOL(format_to, std::, <format>)
+SYMBOL(format_to_n, std::, <format>)
+SYMBOL(format_to_n_result, std::, <format>)
+SYMBOL(formatted_size, std::, <format>)
+SYMBOL(formatter, std::, <format>)
 SYMBOL(forward, std::, <utility>)
 SYMBOL(forward_as_tuple, std::, <tuple>)
+SYMBOL(forward_iterator, std::, <iterator>)
 SYMBOL(forward_iterator_tag, std::, <iterator>)
+SYMBOL(forward_like, std::, <utility>)
 SYMBOL(forward_list, std::, <forward_list>)
 SYMBOL(fpclassify, std::, <cmath>)
 SYMBOL(fpos, std::, <ios>)
 SYMBOL(fpos, std::, <iostream>)
 SYMBOL(fpos, std::, <iosfwd>)
 SYMBOL(fpos_t, std::, <cstdio>)
 SYMBOL(fprintf, std::, <cstdio>)
 SYMBOL(fputc, std::, <cstdio>)
 SYMBOL(fputs, std::, <cstdio>)
 SYMBOL(fputwc, std::, <cwchar>)
 SYMBOL(fputws, std::, <cwchar>)
 SYMBOL(fread, std::, <cstdio>)
 SYMBOL(free, std::, <cstdlib>)
 SYMBOL(freopen, std::, <cstdio>)
 SYMBOL(frexp, std::, <cmath>)
+SYMBOL(frexpf, std::, <cmath>)
+SYMBOL(frexpl, std::, <cmath>)
 SYMBOL(from_chars, std::, <charconv>)
+SYMBOL(from_chars_result, std::, <charconv>)
+SYMBOL(from_range, std::, <ranges>)
+SYMBOL(from_range_t, std::, <ranges>)
 SYMBOL(front_insert_iterator, std::, <iterator>)
 SYMBOL(front_inserter, std::, <iterator>)
 SYMBOL(fscanf, std::, <cstdio>)
 SYMBOL(fseek, std::, <cstdio>)
 SYMBOL(fsetpos, std::, <cstdio>)
 SYMBOL(fstream, std::, <fstream>)
 SYMBOL(fstream, std::, <iosfwd>)
 SYMBOL(ftell, std::, <cstdio>)

 SYMBOL(fwscanf, std::, <cwchar>)
 SYMBOL(gamma_distribution, std::, <random>)
 SYMBOL(gcd, std::, <numeric>)
 SYMBOL(generate, std::, <algorithm>)
 SYMBOL(generate_canonical, std::, <random>)
 SYMBOL(generate_n, std::, <algorithm>)
 SYMBOL(generic_category, std::, <system_error>)
 SYMBOL(geometric_distribution, std::, <random>)
+SYMBOL(get_deleter, std::, <memory>)
 SYMBOL(get_if, std::, <variant>)
 SYMBOL(get_money, std::, <iomanip>)
 SYMBOL(get_new_handler, std::, <new>)
 SYMBOL(get_pointer_safety, std::, <memory>)
+SYMBOL(get_temporary_buffer, std::, <memory>)
 SYMBOL(get_terminate, std::, <exception>)
 SYMBOL(get_time, std::, <iomanip>)
+SYMBOL(get_unexpected, std::, <exception>)
 SYMBOL(getc, std::, <cstdio>)
 SYMBOL(getchar, std::, <cstdio>)
 SYMBOL(getenv, std::, <cstdlib>)
+SYMBOL(getline, std::, <string>)
 SYMBOL(gets, std::, <cstdio>)
 SYMBOL(getwc, std::, <cwchar>)
 SYMBOL(getwchar, std::, <cwchar>)
 SYMBOL(giga, std::, <ratio>)
 SYMBOL(gmtime, std::, <ctime>)
 SYMBOL(greater, std::, <functional>)
 SYMBOL(greater_equal, std::, <functional>)
 SYMBOL(gslice, std::, <valarray>)
 SYMBOL(gslice_array, std::, <valarray>)
 SYMBOL(hardware_constructive_interference_size, std::, <new>)
 SYMBOL(hardware_destructive_interference_size, std::, <new>)
 SYMBOL(has_facet, std::, <locale>)
+SYMBOL(has_single_bit, std::, <bit>)
 SYMBOL(has_unique_object_representations, std::, <type_traits>)
 SYMBOL(has_unique_object_representations_v, std::, <type_traits>)
 SYMBOL(has_virtual_destructor, std::, <type_traits>)
 SYMBOL(has_virtual_destructor_v, std::, <type_traits>)
 SYMBOL(hash, std::, <functional>)
 SYMBOL(hecto, std::, <ratio>)
+SYMBOL(hermite, std::, <cmath>)
+SYMBOL(hermitef, std::, <cmath>)
+SYMBOL(hermitel, std::, <cmath>)
 SYMBOL(hex, std::, <ios>)
 SYMBOL(hex, std::, <iostream>)
 SYMBOL(hexfloat, std::, <ios>)
 SYMBOL(hexfloat, std::, <iostream>)
 SYMBOL(holds_alternative, std::, <variant>)
 SYMBOL(hypot, std::, <cmath>)
+SYMBOL(hypotf, std::, <cmath>)
+SYMBOL(hypotl, std::, <cmath>)
 SYMBOL(identity, std::, <functional>)
 SYMBOL(ifstream, std::, <fstream>)
 SYMBOL(ifstream, std::, <iosfwd>)
 SYMBOL(ignore, std::, <tuple>)
 SYMBOL(ilogb, std::, <cmath>)
+SYMBOL(ilogbf, std::, <cmath>)
+SYMBOL(ilogbl, std::, <cmath>)
 SYMBOL(imag, std::, <complex>)
 SYMBOL(imaxabs, std::, <cinttypes>)
 SYMBOL(imaxdiv, std::, <cinttypes>)
 SYMBOL(imaxdiv_t, std::, <cinttypes>)
 SYMBOL(in_place, std::, <utility>)
 SYMBOL(in_place_index, std::, <utility>)
 SYMBOL(in_place_index_t, std::, <utility>)
 SYMBOL(in_place_t, std::, <utility>)
 SYMBOL(in_place_type, std::, <utility>)
 SYMBOL(in_place_type_t, std::, <utility>)
+SYMBOL(in_range, std::, <utility>)
 SYMBOL(includes, std::, <algorithm>)
 SYMBOL(inclusive_scan, std::, <numeric>)
+SYMBOL(incrementable, std::, <iterator>)
+SYMBOL(incrementable_traits, std::, <iterator>)
 SYMBOL(independent_bits_engine, std::, <random>)
 SYMBOL(indirect_array, std::, <valarray>)
+SYMBOL(indirect_binary_predicate, std::, <iterator>)
+SYMBOL(indirect_equivalence_relation, std::, <iterator>)
+SYMBOL(indirect_result_t, std::, <iterator>)
+SYMBOL(indirect_strict_weak_order, std::, <iterator>)
+SYMBOL(indirect_unary_predicate, std::, <iterator>)
+SYMBOL(indirectly_comparable, std::, <iterator>)
+SYMBOL(indirectly_copyable, std::, <iterator>)
+SYMBOL(indirectly_copyable_storable, std::, <iterator>)
+SYMBOL(indirectly_movable, std::, <iterator>)
+SYMBOL(indirectly_movable_storable, std::, <iterator>)
+SYMBOL(indirectly_readable, std::, <iterator>)
+SYMBOL(indirectly_readable_traits, std::, <iterator>)
+SYMBOL(indirectly_regular_unary_invocable, std::, <iterator>)
+SYMBOL(indirectly_swappable, std::, <iterator>)
+SYMBOL(indirectly_unary_invocable, std::, <iterator>)
+SYMBOL(indirectly_writable, std::, <iterator>)
 SYMBOL(initializer_list, std::, <initializer_list>)
 SYMBOL(inner_product, std::, <numeric>)
+SYMBOL(inout_ptr, std::, <memory>)
+SYMBOL(inout_ptr_t, std::, <memory>)
 SYMBOL(inplace_merge, std::, <algorithm>)
+SYMBOL(input_iterator, std::, <iterator>)
 SYMBOL(input_iterator_tag, std::, <iterator>)
+SYMBOL(input_or_output_iterator, std::, <iterator>)
 SYMBOL(insert_iterator, std::, <iterator>)
 SYMBOL(inserter, std::, <iterator>)
 SYMBOL(int16_t, std::, <cstdint>)
 SYMBOL(int32_t, std::, <cstdint>)
 SYMBOL(int64_t, std::, <cstdint>)
 SYMBOL(int8_t, std::, <cstdint>)
 SYMBOL(int_fast16_t, std::, <cstdint>)
 SYMBOL(int_fast32_t, std::, <cstdint>)
 SYMBOL(int_fast64_t, std::, <cstdint>)
 SYMBOL(int_fast8_t, std::, <cstdint>)
 SYMBOL(int_least16_t, std::, <cstdint>)
 SYMBOL(int_least32_t, std::, <cstdint>)
 SYMBOL(int_least64_t, std::, <cstdint>)
 SYMBOL(int_least8_t, std::, <cstdint>)
 SYMBOL(integer_sequence, std::, <utility>)
+SYMBOL(integral, std::, <concepts>)
 SYMBOL(integral_constant, std::, <type_traits>)
 SYMBOL(internal, std::, <ios>)
 SYMBOL(internal, std::, <iostream>)
 SYMBOL(intmax_t, std::, <cstdint>)
 SYMBOL(intptr_t, std::, <cstdint>)
 SYMBOL(invalid_argument, std::, <stdexcept>)
+SYMBOL(invocable, std::, <concepts>)
 SYMBOL(invoke, std::, <functional>)
+SYMBOL(invoke_r, std::, <functional>)
 SYMBOL(invoke_result, std::, <type_traits>)
 SYMBOL(invoke_result_t, std::, <type_traits>)
 SYMBOL(io_errc, std::, <ios>)
 SYMBOL(io_errc, std::, <iostream>)
+SYMBOL(io_state, std::, <ios>)
+SYMBOL(io_state, std::, <iostream>)
 SYMBOL(ios, std::, <ios>)
 SYMBOL(ios, std::, <iostream>)
 SYMBOL(ios, std::, <iosfwd>)
 SYMBOL(ios_base, std::, <ios>)
 SYMBOL(ios_base, std::, <iostream>)
 SYMBOL(iostream, std::, <istream>)
 SYMBOL(iostream, std::, <iostream>)
 SYMBOL(iostream, std::, <iosfwd>)

 SYMBOL(is_array, std::, <type_traits>)
 SYMBOL(is_array_v, std::, <type_traits>)
 SYMBOL(is_assignable, std::, <type_traits>)
 SYMBOL(is_assignable_v, std::, <type_traits>)
 SYMBOL(is_base_of, std::, <type_traits>)
 SYMBOL(is_base_of_v, std::, <type_traits>)
 SYMBOL(is_bind_expression, std::, <functional>)
 SYMBOL(is_bind_expression_v, std::, <functional>)
+SYMBOL(is_bounded_array, std::, <type_traits>)
+SYMBOL(is_bounded_array_v, std::, <type_traits>)
 SYMBOL(is_class, std::, <type_traits>)
 SYMBOL(is_class_v, std::, <type_traits>)
 SYMBOL(is_compound, std::, <type_traits>)
 SYMBOL(is_compound_v, std::, <type_traits>)
 SYMBOL(is_const, std::, <type_traits>)
 SYMBOL(is_const_v, std::, <type_traits>)
+SYMBOL(is_constant_evaluated, std::, <type_traits>)
 SYMBOL(is_constructible, std::, <type_traits>)
 SYMBOL(is_constructible_v, std::, <type_traits>)
 SYMBOL(is_convertible, std::, <type_traits>)
 SYMBOL(is_convertible_v, std::, <type_traits>)
 SYMBOL(is_copy_assignable, std::, <type_traits>)
 SYMBOL(is_copy_assignable_v, std::, <type_traits>)
 SYMBOL(is_copy_constructible, std::, <type_traits>)
 SYMBOL(is_copy_constructible_v, std::, <type_traits>)
+SYMBOL(is_corresponding_member, std::, <type_traits>)
 SYMBOL(is_default_constructible, std::, <type_traits>)
 SYMBOL(is_default_constructible_v, std::, <type_traits>)
 SYMBOL(is_destructible, std::, <type_traits>)
 SYMBOL(is_destructible_v, std::, <type_traits>)
 SYMBOL(is_empty, std::, <type_traits>)
 SYMBOL(is_empty_v, std::, <type_traits>)
 SYMBOL(is_enum, std::, <type_traits>)
 SYMBOL(is_enum_v, std::, <type_traits>)

 SYMBOL(is_heap, std::, <algorithm>)
 SYMBOL(is_heap_until, std::, <algorithm>)
 SYMBOL(is_integral, std::, <type_traits>)
 SYMBOL(is_integral_v, std::, <type_traits>)
 SYMBOL(is_invocable, std::, <type_traits>)
 SYMBOL(is_invocable_r, std::, <type_traits>)
 SYMBOL(is_invocable_r_v, std::, <type_traits>)
 SYMBOL(is_invocable_v, std::, <type_traits>)
+SYMBOL(is_layout_compatible, std::, <type_traits>)
+SYMBOL(is_layout_compatible_v, std::, <type_traits>)
+SYMBOL(is_literal_type, std::, <type_traits>)
+SYMBOL(is_literal_type_v, std::, <type_traits>)
 SYMBOL(is_lt, std::, <compare>)
 SYMBOL(is_lteq, std::, <compare>)
 SYMBOL(is_lvalue_reference, std::, <type_traits>)
 SYMBOL(is_lvalue_reference_v, std::, <type_traits>)
 SYMBOL(is_member_function_pointer, std::, <type_traits>)
 SYMBOL(is_member_function_pointer_v, std::, <type_traits>)
 SYMBOL(is_member_object_pointer, std::, <type_traits>)
 SYMBOL(is_member_object_pointer_v, std::, <type_traits>)
 SYMBOL(is_member_pointer, std::, <type_traits>)
 SYMBOL(is_member_pointer_v, std::, <type_traits>)
 SYMBOL(is_move_assignable, std::, <type_traits>)
 SYMBOL(is_move_assignable_v, std::, <type_traits>)
 SYMBOL(is_move_constructible, std::, <type_traits>)
 SYMBOL(is_move_constructible_v, std::, <type_traits>)
 SYMBOL(is_neq, std::, <compare>)
 SYMBOL(is_nothrow_assignable, std::, <type_traits>)
 SYMBOL(is_nothrow_assignable_v, std::, <type_traits>)
 SYMBOL(is_nothrow_constructible, std::, <type_traits>)
 SYMBOL(is_nothrow_constructible_v, std::, <type_traits>)
+SYMBOL(is_nothrow_convertible, std::, <type_traits>)
+SYMBOL(is_nothrow_convertible_v, std::, <type_traits>)
 SYMBOL(is_nothrow_copy_assignable, std::, <type_traits>)
 SYMBOL(is_nothrow_copy_assignable_v, std::, <type_traits>)
 SYMBOL(is_nothrow_copy_constructible, std::, <type_traits>)
 SYMBOL(is_nothrow_copy_constructible_v, std::, <type_traits>)
 SYMBOL(is_nothrow_default_constructible, std::, <type_traits>)
 SYMBOL(is_nothrow_default_constructible_v, std::, <type_traits>)
 SYMBOL(is_nothrow_destructible, std::, <type_traits>)
 SYMBOL(is_nothrow_destructible_v, std::, <type_traits>)

 SYMBOL(is_object_v, std::, <type_traits>)
 SYMBOL(is_partitioned, std::, <algorithm>)
 SYMBOL(is_permutation, std::, <algorithm>)
 SYMBOL(is_placeholder, std::, <functional>)
 SYMBOL(is_placeholder_v, std::, <functional>)
 SYMBOL(is_pod, std::, <type_traits>)
 SYMBOL(is_pod_v, std::, <type_traits>)
 SYMBOL(is_pointer, std::, <type_traits>)
+SYMBOL(is_pointer_interconvertible_base_of, std::, <type_traits>)
+SYMBOL(is_pointer_interconvertible_base_of_v, std::, <type_traits>)
+SYMBOL(is_pointer_interconvertible_with_class, std::, <type_traits>)
 SYMBOL(is_pointer_v, std::, <type_traits>)
 SYMBOL(is_polymorphic, std::, <type_traits>)
 SYMBOL(is_polymorphic_v, std::, <type_traits>)
 SYMBOL(is_reference, std::, <type_traits>)
 SYMBOL(is_reference_v, std::, <type_traits>)
 SYMBOL(is_rvalue_reference, std::, <type_traits>)
 SYMBOL(is_rvalue_reference_v, std::, <type_traits>)
 SYMBOL(is_same, std::, <type_traits>)
 SYMBOL(is_same_v, std::, <type_traits>)
 SYMBOL(is_scalar, std::, <type_traits>)
 SYMBOL(is_scalar_v, std::, <type_traits>)
+SYMBOL(is_scoped_enum, std::, <type_traits>)
+SYMBOL(is_scoped_enum_v, std::, <type_traits>)
 SYMBOL(is_signed, std::, <type_traits>)
 SYMBOL(is_signed_v, std::, <type_traits>)
 SYMBOL(is_sorted, std::, <algorithm>)
 SYMBOL(is_sorted_until, std::, <algorithm>)
 SYMBOL(is_standard_layout, std::, <type_traits>)
 SYMBOL(is_standard_layout_v, std::, <type_traits>)
 SYMBOL(is_swappable, std::, <type_traits>)
 SYMBOL(is_swappable_v, std::, <type_traits>)

 SYMBOL(is_trivially_default_constructible, std::, <type_traits>)
 SYMBOL(is_trivially_default_constructible_v, std::, <type_traits>)
 SYMBOL(is_trivially_destructible, std::, <type_traits>)
 SYMBOL(is_trivially_destructible_v, std::, <type_traits>)
 SYMBOL(is_trivially_move_assignable, std::, <type_traits>)
 SYMBOL(is_trivially_move_assignable_v, std::, <type_traits>)
 SYMBOL(is_trivially_move_constructible, std::, <type_traits>)
 SYMBOL(is_trivially_move_constructible_v, std::, <type_traits>)
+SYMBOL(is_unbounded_array, std::, <type_traits>)
+SYMBOL(is_unbounded_array_v, std::, <type_traits>)
 SYMBOL(is_union, std::, <type_traits>)
 SYMBOL(is_union_v, std::, <type_traits>)
 SYMBOL(is_unsigned, std::, <type_traits>)
 SYMBOL(is_unsigned_v, std::, <type_traits>)
 SYMBOL(is_void, std::, <type_traits>)
 SYMBOL(is_void_v, std::, <type_traits>)
 SYMBOL(is_volatile, std::, <type_traits>)
 SYMBOL(is_volatile_v, std::, <type_traits>)
 SYMBOL(isalnum, std::, <cctype>)
 SYMBOL(isalpha, std::, <cctype>)
 SYMBOL(isblank, std::, <cctype>)
 SYMBOL(iscntrl, std::, <cctype>)
 SYMBOL(isdigit, std::, <cctype>)
 SYMBOL(isfinite, std::, <cmath>)
 SYMBOL(isgraph, std::, <cctype>)
 SYMBOL(isgreater, std::, <cmath>)
 SYMBOL(isgreaterequal, std::, <cmath>)
 SYMBOL(isinf, std::, <cmath>)
 SYMBOL(isless, std::, <cmath>)
 SYMBOL(islessequal, std::, <cmath>)
 SYMBOL(islessgreater, std::, <cmath>)
 SYMBOL(islower, std::, <cctype>)
 SYMBOL(isnan, std::, <cmath>)
 SYMBOL(isnormal, std::, <cmath>)
-SYMBOL(ispow2, std::, <bit>)
+SYMBOL(ispanstream, std::, <spanstream>)
+SYMBOL(ispanstream, std::, <iosfwd>)
 SYMBOL(isprint, std::, <cctype>)
 SYMBOL(ispunct, std::, <cctype>)
 SYMBOL(isspace, std::, <cctype>)
 SYMBOL(istream, std::, <istream>)
 SYMBOL(istream, std::, <iostream>)
 SYMBOL(istream, std::, <iosfwd>)
 SYMBOL(istream_iterator, std::, <iterator>)
 SYMBOL(istreambuf_iterator, std::, <iterator>)
 SYMBOL(istreambuf_iterator, std::, <iosfwd>)
 SYMBOL(istringstream, std::, <sstream>)
 SYMBOL(istringstream, std::, <iosfwd>)
+SYMBOL(istrstream, std::, <strstream>)
 SYMBOL(isunordered, std::, <cmath>)
 SYMBOL(isupper, std::, <cctype>)
 SYMBOL(iswalnum, std::, <cwctype>)
 SYMBOL(iswalpha, std::, <cwctype>)
 SYMBOL(iswblank, std::, <cwctype>)
 SYMBOL(iswcntrl, std::, <cwctype>)
 SYMBOL(iswctype, std::, <cwctype>)
 SYMBOL(iswdigit, std::, <cwctype>)
 SYMBOL(iswgraph, std::, <cwctype>)
 SYMBOL(iswlower, std::, <cwctype>)
 SYMBOL(iswprint, std::, <cwctype>)
 SYMBOL(iswpunct, std::, <cwctype>)
 SYMBOL(iswspace, std::, <cwctype>)
 SYMBOL(iswupper, std::, <cwctype>)
 SYMBOL(iswxdigit, std::, <cwctype>)
 SYMBOL(isxdigit, std::, <cctype>)
+SYMBOL(iter_common_reference_t, std::, <iterator>)
+SYMBOL(iter_const_reference_t, std::, <iterator>)
+SYMBOL(iter_difference_t, std::, <iterator>)
+SYMBOL(iter_reference_t, std::, <iterator>)
+SYMBOL(iter_rvalue_reference_t, std::, <iterator>)
 SYMBOL(iter_swap, std::, <algorithm>)
+SYMBOL(iter_value_t, std::, <iterator>)
 SYMBOL(iterator, std::, <iterator>)
 SYMBOL(iterator_traits, std::, <iterator>)
 SYMBOL(jmp_buf, std::, <csetjmp>)
+SYMBOL(jthread, std::, <thread>)
 SYMBOL(kill_dependency, std::, <atomic>)
 SYMBOL(kilo, std::, <ratio>)
 SYMBOL(knuth_b, std::, <random>)
 SYMBOL(labs, std::, <cstdlib>)
+SYMBOL(laguerre, std::, <cmath>)
+SYMBOL(laguerref, std::, <cmath>)
+SYMBOL(laguerrel, std::, <cmath>)
+SYMBOL(latch, std::, <latch>)
 SYMBOL(launch, std::, <future>)
 SYMBOL(launder, std::, <new>)
 SYMBOL(lcm, std::, <numeric>)
 SYMBOL(lconv, std::, <clocale>)
 SYMBOL(ldexp, std::, <cmath>)
+SYMBOL(ldexpf, std::, <cmath>)
+SYMBOL(ldexpl, std::, <cmath>)
 SYMBOL(ldiv, std::, <cstdlib>)
 SYMBOL(ldiv_t, std::, <cstdlib>)
 SYMBOL(left, std::, <ios>)
 SYMBOL(left, std::, <iostream>)
+SYMBOL(legendre, std::, <cmath>)
+SYMBOL(legendref, std::, <cmath>)
+SYMBOL(legendrel, std::, <cmath>)
 SYMBOL(length_error, std::, <stdexcept>)
+SYMBOL(lerp, std::, <cmath>)
 SYMBOL(less, std::, <functional>)
 SYMBOL(less_equal, std::, <functional>)
 SYMBOL(lexicographical_compare, std::, <algorithm>)
-SYMBOL(lexicographical_compare_3way, std::, <algorithm>)
+SYMBOL(lexicographical_compare_three_way, std::, <algorithm>)
 SYMBOL(lgamma, std::, <cmath>)
+SYMBOL(lgammaf, std::, <cmath>)
+SYMBOL(lgammal, std::, <cmath>)
 SYMBOL(linear_congruential_engine, std::, <random>)
 SYMBOL(list, std::, <list>)
 SYMBOL(llabs, std::, <cstdlib>)
 SYMBOL(lldiv, std::, <cstdlib>)
 SYMBOL(lldiv_t, std::, <cstdlib>)
 SYMBOL(llrint, std::, <cmath>)
+SYMBOL(llrintf, std::, <cmath>)
+SYMBOL(llrintl, std::, <cmath>)
 SYMBOL(llround, std::, <cmath>)
+SYMBOL(llroundf, std::, <cmath>)
+SYMBOL(llroundl, std::, <cmath>)
 SYMBOL(locale, std::, <locale>)
 SYMBOL(localeconv, std::, <clocale>)
 SYMBOL(localtime, std::, <ctime>)
 SYMBOL(lock, std::, <mutex>)
 SYMBOL(lock_guard, std::, <mutex>)
 SYMBOL(log, std::, <cmath>)
 SYMBOL(log10, std::, <cmath>)
+SYMBOL(log10f, std::, <cmath>)
+SYMBOL(log10l, std::, <cmath>)
 SYMBOL(log1p, std::, <cmath>)
+SYMBOL(log1pf, std::, <cmath>)
+SYMBOL(log1pl, std::, <cmath>)
 SYMBOL(log2, std::, <cmath>)
-SYMBOL(log2p1, std::, <bit>)
+SYMBOL(log2f, std::, <cmath>)
+SYMBOL(log2l, std::, <cmath>)
 SYMBOL(logb, std::, <cmath>)
+SYMBOL(logbf, std::, <cmath>)
+SYMBOL(logbl, std::, <cmath>)
+SYMBOL(logf, std::, <cmath>)
 SYMBOL(logic_error, std::, <stdexcept>)
 SYMBOL(logical_and, std::, <functional>)
 SYMBOL(logical_not, std::, <functional>)
 SYMBOL(logical_or, std::, <functional>)
+SYMBOL(logl, std::, <cmath>)
 SYMBOL(lognormal_distribution, std::, <random>)
 SYMBOL(longjmp, std::, <csetjmp>)
 SYMBOL(lower_bound, std::, <algorithm>)
 SYMBOL(lrint, std::, <cmath>)
+SYMBOL(lrintf, std::, <cmath>)
+SYMBOL(lrintl, std::, <cmath>)
 SYMBOL(lround, std::, <cmath>)
+SYMBOL(lroundf, std::, <cmath>)
+SYMBOL(lroundl, std::, <cmath>)
 SYMBOL(make_exception_ptr, std::, <exception>)
+SYMBOL(make_format_args, std::, <format>)
 SYMBOL(make_from_tuple, std::, <tuple>)
 SYMBOL(make_heap, std::, <algorithm>)
 SYMBOL(make_move_iterator, std::, <iterator>)
+SYMBOL(make_obj_using_allocator, std::, <memory>)
 SYMBOL(make_optional, std::, <optional>)
 SYMBOL(make_pair, std::, <utility>)
 SYMBOL(make_reverse_iterator, std::, <iterator>)
 SYMBOL(make_shared, std::, <memory>)
+SYMBOL(make_shared_for_overwrite, std::, <memory>)
 SYMBOL(make_signed, std::, <type_traits>)
 SYMBOL(make_signed_t, std::, <type_traits>)
 SYMBOL(make_tuple, std::, <tuple>)
 SYMBOL(make_unique, std::, <memory>)
+SYMBOL(make_unique_for_overwrite, std::, <memory>)
 SYMBOL(make_unsigned, std::, <type_traits>)
 SYMBOL(make_unsigned_t, std::, <type_traits>)
+SYMBOL(make_wformat_args, std::, <format>)
 SYMBOL(malloc, std::, <cstdlib>)
 SYMBOL(map, std::, <map>)
 SYMBOL(mask_array, std::, <valarray>)
 SYMBOL(match_results, std::, <regex>)
 SYMBOL(max, std::, <algorithm>)
 SYMBOL(max_align_t, std::, <cstddef>)
 SYMBOL(max_element, std::, <algorithm>)
 SYMBOL(mblen, std::, <cstdlib>)
 SYMBOL(mbrlen, std::, <cwchar>)
 SYMBOL(mbrtoc16, std::, <cuchar>)
 SYMBOL(mbrtoc32, std::, <cuchar>)
+SYMBOL(mbrtoc8, std::, <cuchar>)
 SYMBOL(mbrtowc, std::, <cwchar>)
 SYMBOL(mbsinit, std::, <cwchar>)
 SYMBOL(mbsrtowcs, std::, <cwchar>)
 SYMBOL(mbstowcs, std::, <cstdlib>)
 SYMBOL(mbtowc, std::, <cstdlib>)
 SYMBOL(mega, std::, <ratio>)
 SYMBOL(mem_fn, std::, <functional>)
+SYMBOL(mem_fun, std::, <functional>)
+SYMBOL(mem_fun1_ref_t, std::, <functional>)
+SYMBOL(mem_fun1_t, std::, <functional>)
+SYMBOL(mem_fun_ref, std::, <functional>)
+SYMBOL(mem_fun_ref_t, std::, <functional>)
+SYMBOL(mem_fun_t, std::, <functional>)
 SYMBOL(memchr, std::, <cstring>)
 SYMBOL(memcmp, std::, <cstring>)
 SYMBOL(memcpy, std::, <cstring>)
 SYMBOL(memmove, std::, <cstring>)
 SYMBOL(memory_order, std::, <atomic>)
 SYMBOL(memory_order_acq_rel, std::, <atomic>)
 SYMBOL(memory_order_acquire, std::, <atomic>)
 SYMBOL(memory_order_consume, std::, <atomic>)
 SYMBOL(memory_order_relaxed, std::, <atomic>)
 SYMBOL(memory_order_release, std::, <atomic>)
 SYMBOL(memory_order_seq_cst, std::, <atomic>)
 SYMBOL(memset, std::, <cstring>)
 SYMBOL(merge, std::, <algorithm>)
+SYMBOL(mergeable, std::, <iterator>)
 SYMBOL(mersenne_twister_engine, std::, <random>)
 SYMBOL(messages, std::, <locale>)
 SYMBOL(messages_base, std::, <locale>)
 SYMBOL(messages_byname, std::, <locale>)
 SYMBOL(micro, std::, <ratio>)
+SYMBOL(midpoint, std::, <numeric>)
 SYMBOL(milli, std::, <ratio>)
 SYMBOL(min, std::, <algorithm>)
 SYMBOL(min_element, std::, <algorithm>)
 SYMBOL(minmax, std::, <algorithm>)
 SYMBOL(minmax_element, std::, <algorithm>)
 SYMBOL(minstd_rand, std::, <random>)
 SYMBOL(minstd_rand0, std::, <random>)
 SYMBOL(minus, std::, <functional>)
 SYMBOL(mismatch, std::, <algorithm>)
 SYMBOL(mktime, std::, <ctime>)
 SYMBOL(modf, std::, <cmath>)
+SYMBOL(modff, std::, <cmath>)
+SYMBOL(modfl, std::, <cmath>)
 SYMBOL(modulus, std::, <functional>)
 SYMBOL(money_base, std::, <locale>)
 SYMBOL(money_get, std::, <locale>)
 SYMBOL(money_put, std::, <locale>)
 SYMBOL(moneypunct, std::, <locale>)
 SYMBOL(moneypunct_byname, std::, <locale>)
 SYMBOL(monostate, std::, <variant>)
+SYMBOL(movable, std::, <concepts>)
 SYMBOL(move_backward, std::, <algorithm>)
+SYMBOL(move_constructible, std::, <concepts>)
 SYMBOL(move_if_noexcept, std::, <utility>)
 SYMBOL(move_iterator, std::, <iterator>)
+SYMBOL(move_only_function, std::, <functional>)
+SYMBOL(move_sentinel, std::, <iterator>)
 SYMBOL(mt19937, std::, <random>)
 SYMBOL(mt19937_64, std::, <random>)
 SYMBOL(multimap, std::, <map>)
 SYMBOL(multiplies, std::, <functional>)
 SYMBOL(multiset, std::, <set>)
 SYMBOL(mutex, std::, <mutex>)
 SYMBOL(nan, std::, <cmath>)
 SYMBOL(nanf, std::, <cmath>)
 SYMBOL(nanl, std::, <cmath>)
 SYMBOL(nano, std::, <ratio>)
 SYMBOL(nearbyint, std::, <cmath>)
+SYMBOL(nearbyintf, std::, <cmath>)
+SYMBOL(nearbyintl, std::, <cmath>)
 SYMBOL(negate, std::, <functional>)
 SYMBOL(negation, std::, <type_traits>)
 SYMBOL(negation_v, std::, <type_traits>)
 SYMBOL(negative_binomial_distribution, std::, <random>)
 SYMBOL(nested_exception, std::, <exception>)
 SYMBOL(new_handler, std::, <new>)
 SYMBOL(next, std::, <iterator>)
 SYMBOL(next_permutation, std::, <algorithm>)
 SYMBOL(nextafter, std::, <cmath>)
+SYMBOL(nextafterf, std::, <cmath>)
+SYMBOL(nextafterl, std::, <cmath>)
 SYMBOL(nexttoward, std::, <cmath>)
-SYMBOL(no_emit_on_flush, std::, <ostream>)
-SYMBOL(no_emit_on_flush, std::, <iostream>)
+SYMBOL(nexttowardf, std::, <cmath>)
+SYMBOL(nexttowardl, std::, <cmath>)
 SYMBOL(noboolalpha, std::, <ios>)
 SYMBOL(noboolalpha, std::, <iostream>)
+SYMBOL(noemit_on_flush, std::, <ostream>)
+SYMBOL(noemit_on_flush, std::, <iostream>)
 SYMBOL(none_of, std::, <algorithm>)
+SYMBOL(noop_coroutine, std::, <coroutine>)
+SYMBOL(noop_coroutine_handle, std::, <coroutine>)
+SYMBOL(noop_coroutine_promise, std::, <coroutine>)
 SYMBOL(norm, std::, <complex>)
 SYMBOL(normal_distribution, std::, <random>)
 SYMBOL(noshowbase, std::, <ios>)
 SYMBOL(noshowbase, std::, <iostream>)
 SYMBOL(noshowpoint, std::, <ios>)
 SYMBOL(noshowpoint, std::, <iostream>)
 SYMBOL(noshowpos, std::, <ios>)
 SYMBOL(noshowpos, std::, <iostream>)
 SYMBOL(noskipws, std::, <ios>)
 SYMBOL(noskipws, std::, <iostream>)
+SYMBOL(nostopstate, std::, <stop_token>)
+SYMBOL(nostopstate_t, std::, <stop_token>)
+SYMBOL(not1, std::, <functional>)
+SYMBOL(not2, std::, <functional>)
 SYMBOL(not_equal_to, std::, <functional>)
 SYMBOL(not_fn, std::, <functional>)
 SYMBOL(nothrow, std::, <new>)
 SYMBOL(nothrow_t, std::, <new>)
 SYMBOL(notify_all_at_thread_exit, std::, <condition_variable>)
 SYMBOL(nounitbuf, std::, <ios>)
 SYMBOL(nounitbuf, std::, <iostream>)
 SYMBOL(nouppercase, std::, <ios>)
 SYMBOL(nouppercase, std::, <iostream>)
 SYMBOL(nth_element, std::, <algorithm>)
 SYMBOL(nullopt, std::, <optional>)
 SYMBOL(nullopt_t, std::, <optional>)
 SYMBOL(nullptr_t, std::, <cstddef>)
 SYMBOL(num_get, std::, <locale>)
 SYMBOL(num_put, std::, <locale>)
 SYMBOL(numeric_limits, std::, <limits>)
 SYMBOL(numpunct, std::, <locale>)
 SYMBOL(numpunct_byname, std::, <locale>)
 SYMBOL(oct, std::, <ios>)
 SYMBOL(oct, std::, <iostream>)
 SYMBOL(ofstream, std::, <fstream>)
 SYMBOL(ofstream, std::, <iosfwd>)
 SYMBOL(once_flag, std::, <mutex>)
+SYMBOL(open_mode, std::, <ios>)
+SYMBOL(open_mode, std::, <iostream>)
 SYMBOL(optional, std::, <optional>)
+SYMBOL(ospanstream, std::, <spanstream>)
+SYMBOL(ospanstream, std::, <iosfwd>)
 SYMBOL(ostream, std::, <ostream>)
 SYMBOL(ostream, std::, <iostream>)
 SYMBOL(ostream, std::, <iosfwd>)
 SYMBOL(ostream_iterator, std::, <iterator>)
 SYMBOL(ostreambuf_iterator, std::, <iterator>)
 SYMBOL(ostreambuf_iterator, std::, <iosfwd>)
 SYMBOL(ostringstream, std::, <sstream>)
 SYMBOL(ostringstream, std::, <iosfwd>)
+SYMBOL(ostrstream, std::, <strstream>)
 SYMBOL(osyncstream, std::, <syncstream>)
 SYMBOL(osyncstream, std::, <iosfwd>)
 SYMBOL(out_of_range, std::, <stdexcept>)
+SYMBOL(out_ptr, std::, <memory>)
+SYMBOL(out_ptr_t, std::, <memory>)
+SYMBOL(output_iterator, std::, <iterator>)
 SYMBOL(output_iterator_tag, std::, <iterator>)
 SYMBOL(overflow_error, std::, <stdexcept>)
 SYMBOL(owner_less, std::, <memory>)
 SYMBOL(packaged_task, std::, <future>)
 SYMBOL(pair, std::, <utility>)
 SYMBOL(partial_order, std::, <compare>)
 SYMBOL(partial_ordering, std::, <compare>)
 SYMBOL(partial_sort, std::, <algorithm>)
 SYMBOL(partial_sort_copy, std::, <algorithm>)
 SYMBOL(partial_sum, std::, <numeric>)
 SYMBOL(partition, std::, <algorithm>)
 SYMBOL(partition_copy, std::, <algorithm>)
 SYMBOL(partition_point, std::, <algorithm>)
+SYMBOL(permutable, std::, <iterator>)
 SYMBOL(perror, std::, <cstdio>)
 SYMBOL(peta, std::, <ratio>)
 SYMBOL(pico, std::, <ratio>)
 SYMBOL(piecewise_constant_distribution, std::, <random>)
+SYMBOL(piecewise_construct, std::, <utility>)
 SYMBOL(piecewise_construct_t, std::, <utility>)
 SYMBOL(piecewise_linear_distribution, std::, <random>)
 SYMBOL(plus, std::, <functional>)
 SYMBOL(pointer_safety, std::, <memory>)
 SYMBOL(pointer_traits, std::, <memory>)
 SYMBOL(poisson_distribution, std::, <random>)
 SYMBOL(polar, std::, <complex>)
-SYMBOL(polymorphic_allocator, std::, <memory_resource>)
 SYMBOL(pop_heap, std::, <algorithm>)
+SYMBOL(popcount, std::, <bit>)
 SYMBOL(pow, std::, <cmath>)
+SYMBOL(powf, std::, <cmath>)
+SYMBOL(powl, std::, <cmath>)
+SYMBOL(predicate, std::, <concepts>)
+SYMBOL(preferred, std::, <memory>)
 SYMBOL(prev, std::, <iterator>)
 SYMBOL(prev_permutation, std::, <algorithm>)
 SYMBOL(printf, std::, <cstdio>)
 SYMBOL(priority_queue, std::, <queue>)
 SYMBOL(proj, std::, <complex>)
+SYMBOL(projected, std::, <iterator>)
 SYMBOL(promise, std::, <future>)
+SYMBOL(ptr_fun, std::, <functional>)
 SYMBOL(ptrdiff_t, std::, <cstddef>)
 SYMBOL(push_heap, std::, <algorithm>)
 SYMBOL(put_money, std::, <iomanip>)
 SYMBOL(put_time, std::, <iomanip>)
 SYMBOL(putc, std::, <cstdio>)
 SYMBOL(putchar, std::, <cstdio>)
 SYMBOL(puts, std::, <cstdio>)
 SYMBOL(putwc, std::, <cwchar>)
 SYMBOL(putwchar, std::, <cwchar>)
 SYMBOL(qsort, std::, <cstdlib>)
 SYMBOL(queue, std::, <queue>)
 SYMBOL(quick_exit, std::, <cstdlib>)
 SYMBOL(quoted, std::, <iomanip>)
 SYMBOL(raise, std::, <csignal>)
 SYMBOL(rand, std::, <cstdlib>)
+SYMBOL(random_access_iterator, std::, <iterator>)
 SYMBOL(random_access_iterator_tag, std::, <iterator>)
 SYMBOL(random_device, std::, <random>)
 SYMBOL(random_shuffle, std::, <algorithm>)
 SYMBOL(range_error, std::, <stdexcept>)
 SYMBOL(rank, std::, <type_traits>)
 SYMBOL(rank_v, std::, <type_traits>)
 SYMBOL(ranlux24, std::, <random>)
 SYMBOL(ranlux24_base, std::, <random>)

 SYMBOL(ratio_less, std::, <ratio>)
 SYMBOL(ratio_less_equal, std::, <ratio>)
 SYMBOL(ratio_less_equal_v, std::, <ratio>)
 SYMBOL(ratio_less_v, std::, <ratio>)
 SYMBOL(ratio_multiply, std::, <ratio>)
 SYMBOL(ratio_not_equal, std::, <ratio>)
 SYMBOL(ratio_not_equal_v, std::, <ratio>)
 SYMBOL(ratio_subtract, std::, <ratio>)
-SYMBOL(rbegin, std::, <iterator>)
+SYMBOL(raw_storage_iterator, std::, <memory>)
 SYMBOL(real, std::, <complex>)
 SYMBOL(realloc, std::, <cstdlib>)
 SYMBOL(recursive_mutex, std::, <mutex>)
 SYMBOL(recursive_timed_mutex, std::, <mutex>)
 SYMBOL(reduce, std::, <numeric>)
 SYMBOL(ref, std::, <functional>)
 SYMBOL(reference_wrapper, std::, <functional>)
 SYMBOL(regex, std::, <regex>)
 SYMBOL(regex_error, std::, <regex>)
 SYMBOL(regex_iterator, std::, <regex>)
 SYMBOL(regex_match, std::, <regex>)
 SYMBOL(regex_replace, std::, <regex>)
 SYMBOL(regex_search, std::, <regex>)
 SYMBOL(regex_token_iterator, std::, <regex>)
 SYMBOL(regex_traits, std::, <regex>)
+SYMBOL(regular, std::, <concepts>)
+SYMBOL(regular_invocable, std::, <concepts>)
 SYMBOL(reinterpret_pointer_cast, std::, <memory>)
+SYMBOL(relation, std::, <concepts>)
 SYMBOL(remainder, std::, <cmath>)
+SYMBOL(remainderf, std::, <cmath>)
+SYMBOL(remainderl, std::, <cmath>)
 SYMBOL(remove_all_extents, std::, <type_traits>)
 SYMBOL(remove_all_extents_t, std::, <type_traits>)
 SYMBOL(remove_const, std::, <type_traits>)
 SYMBOL(remove_const_t, std::, <type_traits>)
 SYMBOL(remove_copy, std::, <algorithm>)
 SYMBOL(remove_copy_if, std::, <algorithm>)
 SYMBOL(remove_cv, std::, <type_traits>)
 SYMBOL(remove_cv_t, std::, <type_traits>)
 SYMBOL(remove_cvref, std::, <type_traits>)
 SYMBOL(remove_cvref_t, std::, <type_traits>)
 SYMBOL(remove_extent, std::, <type_traits>)
 SYMBOL(remove_extent_t, std::, <type_traits>)
+SYMBOL(remove_if, std::, <algorithm>)
 SYMBOL(remove_pointer, std::, <type_traits>)
 SYMBOL(remove_pointer_t, std::, <type_traits>)
 SYMBOL(remove_reference, std::, <type_traits>)
 SYMBOL(remove_reference_t, std::, <type_traits>)
 SYMBOL(remove_volatile, std::, <type_traits>)
 SYMBOL(remove_volatile_t, std::, <type_traits>)
 SYMBOL(remquo, std::, <cmath>)
+SYMBOL(remquof, std::, <cmath>)
+SYMBOL(remquol, std::, <cmath>)
 SYMBOL(rename, std::, <cstdio>)
-SYMBOL(rend, std::, <iterator>)
 SYMBOL(replace, std::, <algorithm>)
 SYMBOL(replace_copy, std::, <algorithm>)
 SYMBOL(replace_copy_if, std::, <algorithm>)
 SYMBOL(replace_if, std::, <algorithm>)
 SYMBOL(resetiosflags, std::, <iomanip>)
 SYMBOL(result_of, std::, <type_traits>)
 SYMBOL(result_of_t, std::, <type_traits>)
 SYMBOL(rethrow_exception, std::, <exception>)
 SYMBOL(rethrow_if_nested, std::, <exception>)
+SYMBOL(return_temporary_buffer, std::, <memory>)
 SYMBOL(reverse, std::, <algorithm>)
 SYMBOL(reverse_copy, std::, <algorithm>)
 SYMBOL(reverse_iterator, std::, <iterator>)
 SYMBOL(rewind, std::, <cstdio>)
+SYMBOL(riemann_zeta, std::, <cmath>)
+SYMBOL(riemann_zetaf, std::, <cmath>)
+SYMBOL(riemann_zetal, std::, <cmath>)
 SYMBOL(right, std::, <ios>)
 SYMBOL(right, std::, <iostream>)
 SYMBOL(rint, std::, <cmath>)
+SYMBOL(rintf, std::, <cmath>)
+SYMBOL(rintl, std::, <cmath>)
 SYMBOL(rotate, std::, <algorithm>)
 SYMBOL(rotate_copy, std::, <algorithm>)
+SYMBOL(rotl, std::, <bit>)
+SYMBOL(rotr, std::, <bit>)
 SYMBOL(round, std::, <cmath>)
 SYMBOL(round_indeterminate, std::, <limits>)
 SYMBOL(round_to_nearest, std::, <limits>)
 SYMBOL(round_toward_infinity, std::, <limits>)
 SYMBOL(round_toward_neg_infinity, std::, <limits>)
 SYMBOL(round_toward_zero, std::, <limits>)
+SYMBOL(roundf, std::, <cmath>)
+SYMBOL(roundl, std::, <cmath>)
 SYMBOL(runtime_error, std::, <stdexcept>)
+SYMBOL(same_as, std::, <concepts>)
 SYMBOL(sample, std::, <algorithm>)
 SYMBOL(scalbln, std::, <cmath>)
+SYMBOL(scalblnf, std::, <cmath>)
+SYMBOL(scalblnl, std::, <cmath>)
 SYMBOL(scalbn, std::, <cmath>)
+SYMBOL(scalbnf, std::, <cmath>)
+SYMBOL(scalbnl, std::, <cmath>)
 SYMBOL(scanf, std::, <cstdio>)
 SYMBOL(scientific, std::, <ios>)
 SYMBOL(scientific, std::, <iostream>)
 SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>)
+SYMBOL(scoped_lock, std::, <mutex>)
 SYMBOL(search, std::, <algorithm>)
 SYMBOL(search_n, std::, <algorithm>)
 SYMBOL(seed_seq, std::, <random>)
+SYMBOL(seek_dir, std::, <ios>)
+SYMBOL(seek_dir, std::, <iostream>)
+SYMBOL(semiregular, std::, <concepts>)
+SYMBOL(sentinel_for, std::, <iterator>)
 SYMBOL(set, std::, <set>)
 SYMBOL(set_difference, std::, <algorithm>)
 SYMBOL(set_intersection, std::, <algorithm>)
 SYMBOL(set_new_handler, std::, <new>)
 SYMBOL(set_symmetric_difference, std::, <algorithm>)
 SYMBOL(set_terminate, std::, <exception>)
+SYMBOL(set_unexpected, std::, <exception>)
 SYMBOL(set_union, std::, <algorithm>)
 SYMBOL(setbase, std::, <iomanip>)
 SYMBOL(setbuf, std::, <cstdio>)
 SYMBOL(setfill, std::, <iomanip>)
 SYMBOL(setiosflags, std::, <iomanip>)
 SYMBOL(setlocale, std::, <clocale>)
 SYMBOL(setprecision, std::, <iomanip>)
 SYMBOL(setvbuf, std::, <cstdio>)

 SYMBOL(showpoint, std::, <iostream>)
 SYMBOL(showpos, std::, <ios>)
 SYMBOL(showpos, std::, <iostream>)
 SYMBOL(shuffle, std::, <algorithm>)
 SYMBOL(shuffle_order_engine, std::, <random>)
 SYMBOL(sig_atomic_t, std::, <csignal>)
 SYMBOL(signal, std::, <csignal>)
 SYMBOL(signbit, std::, <cmath>)
+SYMBOL(signed_integral, std::, <concepts>)
 SYMBOL(sin, std::, <cmath>)
+SYMBOL(sinf, std::, <cmath>)
 SYMBOL(sinh, std::, <cmath>)
-SYMBOL(size, std::, <iterator>)
+SYMBOL(sinhf, std::, <cmath>)
+SYMBOL(sinhl, std::, <cmath>)
+SYMBOL(sinl, std::, <cmath>)
+SYMBOL(sized_sentinel_for, std::, <iterator>)
 SYMBOL(skipws, std::, <ios>)
 SYMBOL(skipws, std::, <iostream>)
 SYMBOL(slice, std::, <valarray>)
 SYMBOL(slice_array, std::, <valarray>)
 SYMBOL(smatch, std::, <regex>)
 SYMBOL(snprintf, std::, <cstdio>)
 SYMBOL(sort, std::, <algorithm>)
 SYMBOL(sort_heap, std::, <algorithm>)
+SYMBOL(sortable, std::, <iterator>)
+SYMBOL(source_location, std::, <source_location>)
 SYMBOL(span, std::, <span>)
+SYMBOL(spanbuf, std::, <spanstream>)
+SYMBOL(spanbuf, std::, <iosfwd>)
+SYMBOL(spanstream, std::, <spanstream>)
+SYMBOL(spanstream, std::, <iosfwd>)
+SYMBOL(sph_bessel, std::, <cmath>)
+SYMBOL(sph_besself, std::, <cmath>)
+SYMBOL(sph_bessell, std::, <cmath>)
+SYMBOL(sph_legendre, std::, <cmath>)
+SYMBOL(sph_legendref, std::, <cmath>)
+SYMBOL(sph_legendrel, std::, <cmath>)
+SYMBOL(sph_neumann, std::, <cmath>)
+SYMBOL(sph_neumannf, std::, <cmath>)
+SYMBOL(sph_neumannl, std::, <cmath>)
 SYMBOL(sprintf, std::, <cstdio>)
 SYMBOL(sqrt, std::, <cmath>)
+SYMBOL(sqrtf, std::, <cmath>)
+SYMBOL(sqrtl, std::, <cmath>)
 SYMBOL(srand, std::, <cstdlib>)
 SYMBOL(sregex_iterator, std::, <regex>)
 SYMBOL(sregex_token_iterator, std::, <regex>)
 SYMBOL(sscanf, std::, <cstdio>)
 SYMBOL(ssub_match, std::, <regex>)
 SYMBOL(stable_partition, std::, <algorithm>)
 SYMBOL(stable_sort, std::, <algorithm>)
 SYMBOL(stack, std::, <stack>)
+SYMBOL(stacktrace, std::, <stacktrace>)
+SYMBOL(stacktrace_entry, std::, <stacktrace>)
 SYMBOL(static_pointer_cast, std::, <memory>)
+SYMBOL(stod, std::, <string>)
+SYMBOL(stof, std::, <string>)
+SYMBOL(stoi, std::, <string>)
+SYMBOL(stol, std::, <string>)
+SYMBOL(stold, std::, <string>)
+SYMBOL(stoll, std::, <string>)
+SYMBOL(stop_callback, std::, <stop_token>)
+SYMBOL(stop_source, std::, <stop_token>)
+SYMBOL(stop_token, std::, <stop_token>)
+SYMBOL(stoul, std::, <string>)
+SYMBOL(stoull, std::, <string>)
 SYMBOL(strcat, std::, <cstring>)
 SYMBOL(strchr, std::, <cstring>)
 SYMBOL(strcmp, std::, <cstring>)
 SYMBOL(strcoll, std::, <cstring>)
 SYMBOL(strcpy, std::, <cstring>)
 SYMBOL(strcspn, std::, <cstring>)
 SYMBOL(streambuf, std::, <streambuf>)
 SYMBOL(streambuf, std::, <iostream>)
 SYMBOL(streambuf, std::, <iosfwd>)
 SYMBOL(streamoff, std::, <ios>)
 SYMBOL(streamoff, std::, <iostream>)
-SYMBOL(streampos, std::, <ios>)
-SYMBOL(streampos, std::, <iostream>)
+SYMBOL(streampos, std::, <iosfwd>)
 SYMBOL(streampos, std::, <iosfwd>)
 SYMBOL(streamsize, std::, <ios>)
 SYMBOL(streamsize, std::, <iostream>)
 SYMBOL(strerror, std::, <cstring>)
 SYMBOL(strftime, std::, <ctime>)
+SYMBOL(strict, std::, <memory>)
+SYMBOL(strict_weak_order, std::, <concepts>)
 SYMBOL(string, std::, <string>)
 SYMBOL(string_view, std::, <string_view>)
 SYMBOL(stringbuf, std::, <sstream>)
 SYMBOL(stringbuf, std::, <iosfwd>)
 SYMBOL(stringstream, std::, <sstream>)
 SYMBOL(stringstream, std::, <iosfwd>)
 SYMBOL(strlen, std::, <cstring>)
 SYMBOL(strncat, std::, <cstring>)
 SYMBOL(strncmp, std::, <cstring>)
 SYMBOL(strncpy, std::, <cstring>)
-SYMBOL(strong_equal, std::, <compare>)
-SYMBOL(strong_equality, std::, <compare>)
 SYMBOL(strong_order, std::, <compare>)
 SYMBOL(strong_ordering, std::, <compare>)
 SYMBOL(strpbrk, std::, <cstring>)
 SYMBOL(strrchr, std::, <cstring>)
 SYMBOL(strspn, std::, <cstring>)
 SYMBOL(strstr, std::, <cstring>)
+SYMBOL(strstream, std::, <strstream>)
+SYMBOL(strstreambuf, std::, <strstream>)
 SYMBOL(strtod, std::, <cstdlib>)
 SYMBOL(strtof, std::, <cstdlib>)
 SYMBOL(strtoimax, std::, <cinttypes>)
 SYMBOL(strtok, std::, <cstring>)
 SYMBOL(strtol, std::, <cstdlib>)
 SYMBOL(strtold, std::, <cstdlib>)
 SYMBOL(strtoll, std::, <cstdlib>)
 SYMBOL(strtoul, std::, <cstdlib>)
 SYMBOL(strtoull, std::, <cstdlib>)
 SYMBOL(strtoumax, std::, <cinttypes>)
 SYMBOL(strxfrm, std::, <cstring>)
 SYMBOL(student_t_distribution, std::, <random>)
 SYMBOL(sub_match, std::, <regex>)
 SYMBOL(subtract_with_carry_engine, std::, <random>)
+SYMBOL(suspend_always, std::, <coroutine>)
+SYMBOL(suspend_never, std::, <coroutine>)
 SYMBOL(swap_ranges, std::, <algorithm>)
+SYMBOL(swappable, std::, <concepts>)
+SYMBOL(swappable_with, std::, <concepts>)
 SYMBOL(swprintf, std::, <cwchar>)
 SYMBOL(swscanf, std::, <cwchar>)
 SYMBOL(syncbuf, std::, <syncstream>)
 SYMBOL(syncbuf, std::, <iosfwd>)
 SYMBOL(system, std::, <cstdlib>)
 SYMBOL(system_category, std::, <system_error>)
 SYMBOL(system_error, std::, <system_error>)
 SYMBOL(tan, std::, <cmath>)
+SYMBOL(tanf, std::, <cmath>)
 SYMBOL(tanh, std::, <cmath>)
+SYMBOL(tanhf, std::, <cmath>)
+SYMBOL(tanhl, std::, <cmath>)
+SYMBOL(tanl, std::, <cmath>)
 SYMBOL(tera, std::, <ratio>)
 SYMBOL(terminate, std::, <exception>)
 SYMBOL(terminate_handler, std::, <exception>)
 SYMBOL(tgamma, std::, <cmath>)
+SYMBOL(tgammaf, std::, <cmath>)
+SYMBOL(tgammal, std::, <cmath>)
 SYMBOL(thread, std::, <thread>)
+SYMBOL(three_way_comparable, std::, <compare>)
+SYMBOL(three_way_comparable_with, std::, <compare>)
 SYMBOL(throw_with_nested, std::, <exception>)
 SYMBOL(tie, std::, <tuple>)
 SYMBOL(time, std::, <ctime>)
 SYMBOL(time_base, std::, <locale>)
 SYMBOL(time_get, std::, <locale>)
 SYMBOL(time_get_byname, std::, <locale>)
 SYMBOL(time_put, std::, <locale>)
 SYMBOL(time_put_byname, std::, <locale>)
 SYMBOL(time_t, std::, <ctime>)
 SYMBOL(timed_mutex, std::, <mutex>)
 SYMBOL(timespec, std::, <ctime>)
 SYMBOL(timespec_get, std::, <ctime>)
 SYMBOL(tm, std::, <ctime>)
 SYMBOL(tmpfile, std::, <cstdio>)
 SYMBOL(tmpnam, std::, <cstdio>)
 SYMBOL(to_address, std::, <memory>)
+SYMBOL(to_array, std::, <array>)
 SYMBOL(to_chars, std::, <charconv>)
+SYMBOL(to_chars_result, std::, <charconv>)
 SYMBOL(to_integer, std::, <cstddef>)
 SYMBOL(to_string, std::, <string>)
+SYMBOL(to_underlying, std::, <utility>)
+SYMBOL(to_wstring, std::, <string>)
 SYMBOL(tolower, std::, <cctype>)
+SYMBOL(totally_ordered, std::, <concepts>)
+SYMBOL(totally_ordered_with, std::, <concepts>)
 SYMBOL(toupper, std::, <cctype>)
 SYMBOL(towctrans, std::, <cwctype>)
 SYMBOL(towlower, std::, <cwctype>)
 SYMBOL(towupper, std::, <cwctype>)
 SYMBOL(transform, std::, <algorithm>)
 SYMBOL(transform_exclusive_scan, std::, <numeric>)
 SYMBOL(transform_inclusive_scan, std::, <numeric>)
 SYMBOL(transform_reduce, std::, <numeric>)
 SYMBOL(true_type, std::, <type_traits>)
 SYMBOL(trunc, std::, <cmath>)
+SYMBOL(truncf, std::, <cmath>)
+SYMBOL(truncl, std::, <cmath>)
 SYMBOL(try_lock, std::, <mutex>)
 SYMBOL(try_to_lock, std::, <mutex>)
 SYMBOL(try_to_lock_t, std::, <mutex>)
 SYMBOL(tuple, std::, <tuple>)
 SYMBOL(tuple_cat, std::, <tuple>)
+SYMBOL(tuple_element_t, std::, <tuple>)
+SYMBOL(tuple_size_v, std::, <tuple>)
 SYMBOL(type_identity, std::, <type_traits>)
 SYMBOL(type_identity_t, std::, <type_traits>)
 SYMBOL(type_index, std::, <typeindex>)
 SYMBOL(type_info, std::, <typeinfo>)
-SYMBOL(u16streampos, std::, <ios>)
-SYMBOL(u16streampos, std::, <iostream>)
+SYMBOL(u16streampos, std::, <iosfwd>)
 SYMBOL(u16streampos, std::, <iosfwd>)
 SYMBOL(u16string, std::, <string>)
 SYMBOL(u16string_view, std::, <string_view>)
-SYMBOL(u32streampos, std::, <ios>)
-SYMBOL(u32streampos, std::, <iostream>)
+SYMBOL(u32streampos, std::, <iosfwd>)
 SYMBOL(u32streampos, std::, <iosfwd>)
 SYMBOL(u32string, std::, <string>)
 SYMBOL(u32string_view, std::, <string_view>)
+SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(u8string, std::, <string>)
+SYMBOL(u8string_view, std::, <string_view>)
 SYMBOL(uint16_t, std::, <cstdint>)
 SYMBOL(uint32_t, std::, <cstdint>)
 SYMBOL(uint64_t, std::, <cstdint>)
 SYMBOL(uint8_t, std::, <cstdint>)
 SYMBOL(uint_fast16_t, std::, <cstdint>)
 SYMBOL(uint_fast32_t, std::, <cstdint>)
 SYMBOL(uint_fast64_t, std::, <cstdint>)
 SYMBOL(uint_fast8_t, std::, <cstdint>)
 SYMBOL(uint_least16_t, std::, <cstdint>)
 SYMBOL(uint_least32_t, std::, <cstdint>)
 SYMBOL(uint_least64_t, std::, <cstdint>)
 SYMBOL(uint_least8_t, std::, <cstdint>)
 SYMBOL(uintmax_t, std::, <cstdint>)
 SYMBOL(uintptr_t, std::, <cstdint>)
+SYMBOL(unary_function, std::, <functional>)
+SYMBOL(unary_negate, std::, <functional>)
+SYMBOL(uncaught_exception, std::, <exception>)
 SYMBOL(uncaught_exceptions, std::, <exception>)
 SYMBOL(undeclare_no_pointers, std::, <memory>)
 SYMBOL(undeclare_reachable, std::, <memory>)
 SYMBOL(underflow_error, std::, <stdexcept>)
 SYMBOL(underlying_type, std::, <type_traits>)
 SYMBOL(underlying_type_t, std::, <type_traits>)
+SYMBOL(unexpected_handler, std::, <exception>)
 SYMBOL(ungetc, std::, <cstdio>)
 SYMBOL(ungetwc, std::, <cwchar>)
 SYMBOL(uniform_int_distribution, std::, <random>)
+SYMBOL(uniform_random_bit_generator, std::, <random>)
 SYMBOL(uniform_real_distribution, std::, <random>)
+SYMBOL(uninitialized_construct_using_allocator, std::, <memory>)
 SYMBOL(uninitialized_copy, std::, <memory>)
 SYMBOL(uninitialized_copy_n, std::, <memory>)
 SYMBOL(uninitialized_default_construct, std::, <memory>)
 SYMBOL(uninitialized_default_construct_n, std::, <memory>)
 SYMBOL(uninitialized_fill, std::, <memory>)
 SYMBOL(uninitialized_fill_n, std::, <memory>)
 SYMBOL(uninitialized_move, std::, <memory>)
 SYMBOL(uninitialized_move_n, std::, <memory>)
 SYMBOL(uninitialized_value_construct, std::, <memory>)
 SYMBOL(uninitialized_value_construct_n, std::, <memory>)
 SYMBOL(unique, std::, <algorithm>)
 SYMBOL(unique_copy, std::, <algorithm>)
 SYMBOL(unique_lock, std::, <mutex>)
 SYMBOL(unique_ptr, std::, <memory>)
 SYMBOL(unitbuf, std::, <ios>)
 SYMBOL(unitbuf, std::, <iostream>)
 SYMBOL(unordered_map, std::, <unordered_map>)
 SYMBOL(unordered_multimap, std::, <unordered_map>)
 SYMBOL(unordered_multiset, std::, <unordered_set>)
 SYMBOL(unordered_set, std::, <unordered_set>)
+SYMBOL(unreachable, std::, <utility>)
+SYMBOL(unreachable_sentinel, std::, <iterator>)
+SYMBOL(unreachable_sentinel_t, std::, <iterator>)
+SYMBOL(unsigned_integral, std::, <concepts>)
 SYMBOL(upper_bound, std::, <algorithm>)
 SYMBOL(uppercase, std::, <ios>)
 SYMBOL(uppercase, std::, <iostream>)
 SYMBOL(use_facet, std::, <locale>)
 SYMBOL(uses_allocator, std::, <memory>)
+SYMBOL(uses_allocator_construction_args, std::, <memory>)
 SYMBOL(uses_allocator_v, std::, <memory>)
 SYMBOL(va_list, std::, <cstdarg>)
 SYMBOL(valarray, std::, <valarray>)
 SYMBOL(variant, std::, <variant>)
 SYMBOL(variant_alternative, std::, <variant>)
 SYMBOL(variant_alternative_t, std::, <variant>)
 SYMBOL(variant_npos, std::, <variant>)
 SYMBOL(variant_size, std::, <variant>)
 SYMBOL(variant_size_v, std::, <variant>)
 SYMBOL(vector, std::, <vector>)
+SYMBOL(vformat, std::, <format>)
+SYMBOL(vformat_to, std::, <format>)
 SYMBOL(vfprintf, std::, <cstdio>)
 SYMBOL(vfscanf, std::, <cstdio>)
 SYMBOL(vfwprintf, std::, <cwchar>)
 SYMBOL(vfwscanf, std::, <cwchar>)
 SYMBOL(visit, std::, <variant>)
+SYMBOL(visit_format_arg, std::, <format>)
 SYMBOL(void_t, std::, <type_traits>)
 SYMBOL(vprintf, std::, <cstdio>)
 SYMBOL(vscanf, std::, <cstdio>)
 SYMBOL(vsnprintf, std::, <cstdio>)
 SYMBOL(vsprintf, std::, <cstdio>)
 SYMBOL(vsscanf, std::, <cstdio>)
 SYMBOL(vswprintf, std::, <cwchar>)
 SYMBOL(vswscanf, std::, <cwchar>)

 SYMBOL(wcsub_match, std::, <regex>)
 SYMBOL(wcsxfrm, std::, <cwchar>)
 SYMBOL(wctob, std::, <cwchar>)
 SYMBOL(wctomb, std::, <cstdlib>)
 SYMBOL(wctrans, std::, <cwctype>)
 SYMBOL(wctrans_t, std::, <cwctype>)
 SYMBOL(wctype, std::, <cwctype>)
 SYMBOL(wctype_t, std::, <cwctype>)
-SYMBOL(weak_equal, std::, <compare>)
-SYMBOL(weak_equality, std::, <compare>)
 SYMBOL(weak_order, std::, <compare>)
 SYMBOL(weak_ordering, std::, <compare>)
 SYMBOL(weak_ptr, std::, <memory>)
+SYMBOL(weakly_incrementable, std::, <iterator>)
 SYMBOL(weibull_distribution, std::, <random>)
 SYMBOL(wfilebuf, std::, <streambuf>)
 SYMBOL(wfilebuf, std::, <iostream>)
 SYMBOL(wfilebuf, std::, <iosfwd>)
+SYMBOL(wformat_args, std::, <format>)
+SYMBOL(wformat_context, std::, <format>)
+SYMBOL(wformat_parse_context, std::, <format>)
 SYMBOL(wfstream, std::, <fstream>)
 SYMBOL(wfstream, std::, <iosfwd>)
 SYMBOL(wifstream, std::, <fstream>)
 SYMBOL(wifstream, std::, <iosfwd>)
 SYMBOL(wios, std::, <ios>)
 SYMBOL(wios, std::, <iostream>)
 SYMBOL(wios, std::, <iosfwd>)
 SYMBOL(wiostream, std::, <istream>)
 SYMBOL(wiostream, std::, <iostream>)
 SYMBOL(wiostream, std::, <iosfwd>)
+SYMBOL(wispanstream, std::, <spanstream>)
+SYMBOL(wispanstream, std::, <iosfwd>)
 SYMBOL(wistream, std::, <istream>)
 SYMBOL(wistream, std::, <iostream>)
 SYMBOL(wistream, std::, <iosfwd>)
 SYMBOL(wistringstream, std::, <sstream>)
 SYMBOL(wistringstream, std::, <iosfwd>)
 SYMBOL(wmemchr, std::, <cwchar>)
 SYMBOL(wmemcmp, std::, <cwchar>)
 SYMBOL(wmemcpy, std::, <cwchar>)
 SYMBOL(wmemmove, std::, <cwchar>)
 SYMBOL(wmemset, std::, <cwchar>)
 SYMBOL(wofstream, std::, <fstream>)
 SYMBOL(wofstream, std::, <iosfwd>)
+SYMBOL(wospanstream, std::, <spanstream>)
+SYMBOL(wospanstream, std::, <iosfwd>)
 SYMBOL(wostream, std::, <ostream>)
 SYMBOL(wostream, std::, <iostream>)
 SYMBOL(wostream, std::, <iosfwd>)
 SYMBOL(wostringstream, std::, <sstream>)
 SYMBOL(wostringstream, std::, <iosfwd>)
 SYMBOL(wosyncstream, std::, <syncstream>)
 SYMBOL(wosyncstream, std::, <iosfwd>)
 SYMBOL(wprintf, std::, <cwchar>)
 SYMBOL(wregex, std::, <regex>)
 SYMBOL(ws, std::, <istream>)
 SYMBOL(ws, std::, <iostream>)
 SYMBOL(wscanf, std::, <cwchar>)
 SYMBOL(wsmatch, std::, <regex>)
+SYMBOL(wspanbuf, std::, <spanstream>)
+SYMBOL(wspanbuf, std::, <iosfwd>)
+SYMBOL(wspanstream, std::, <spanstream>)
+SYMBOL(wspanstream, std::, <iosfwd>)
 SYMBOL(wsregex_iterator, std::, <regex>)
 SYMBOL(wsregex_token_iterator, std::, <regex>)
 SYMBOL(wssub_match, std::, <regex>)
 SYMBOL(wstreambuf, std::, <streambuf>)
 SYMBOL(wstreambuf, std::, <iostream>)
 SYMBOL(wstreambuf, std::, <iosfwd>)
-SYMBOL(wstreampos, std::, <ios>)
-SYMBOL(wstreampos, std::, <iostream>)
+SYMBOL(wstreampos, std::, <iosfwd>)
 SYMBOL(wstreampos, std::, <iosfwd>)
 SYMBOL(wstring, std::, <string>)
 SYMBOL(wstring_convert, std::, <locale>)
 SYMBOL(wstring_view, std::, <string_view>)
 SYMBOL(wstringbuf, std::, <sstream>)
 SYMBOL(wstringbuf, std::, <iosfwd>)
 SYMBOL(wstringstream, std::, <sstream>)
 SYMBOL(wstringstream, std::, <iosfwd>)

 SYMBOL(Saturday, std::chrono::, <chrono>)
 SYMBOL(September, std::chrono::, <chrono>)
 SYMBOL(Sunday, std::chrono::, <chrono>)
 SYMBOL(Thursday, std::chrono::, <chrono>)
 SYMBOL(Tuesday, std::chrono::, <chrono>)
 SYMBOL(Wednesday, std::chrono::, <chrono>)
 SYMBOL(abs, std::chrono::, <chrono>)
 SYMBOL(ambiguous_local_time, std::chrono::, <chrono>)
-SYMBOL(ceil, std::chrono::, <chrono>)
 SYMBOL(choose, std::chrono::, <chrono>)
 SYMBOL(clock_cast, std::chrono::, <chrono>)
 SYMBOL(clock_time_conversion, std::chrono::, <chrono>)
 SYMBOL(current_zone, std::chrono::, <chrono>)
 SYMBOL(day, std::chrono::, <chrono>)
 SYMBOL(duration, std::chrono::, <chrono>)
+SYMBOL(duration_cast, std::chrono::, <chrono>)
 SYMBOL(duration_values, std::chrono::, <chrono>)
 SYMBOL(file_clock, std::chrono::, <chrono>)
 SYMBOL(file_seconds, std::chrono::, <chrono>)
 SYMBOL(file_time, std::chrono::, <chrono>)
-SYMBOL(floor, std::chrono::, <chrono>)
+SYMBOL(get_leap_second_info, std::chrono::, <chrono>)
 SYMBOL(gps_clock, std::chrono::, <chrono>)
 SYMBOL(gps_seconds, std::chrono::, <chrono>)
 SYMBOL(gps_time, std::chrono::, <chrono>)
+SYMBOL(hh_mm_ss, std::chrono::, <chrono>)
 SYMBOL(high_resolution_clock, std::chrono::, <chrono>)
 SYMBOL(hours, std::chrono::, <chrono>)
+SYMBOL(is_am, std::chrono::, <chrono>)
 SYMBOL(is_clock, std::chrono::, <chrono>)
 SYMBOL(is_clock_v, std::chrono::, <chrono>)
+SYMBOL(is_pm, std::chrono::, <chrono>)
 SYMBOL(last, std::chrono::, <chrono>)
 SYMBOL(last_spec, std::chrono::, <chrono>)
-SYMBOL(leap, std::chrono::, <chrono>)
-SYMBOL(link, std::chrono::, <chrono>)
+SYMBOL(leap_second, std::chrono::, <chrono>)
+SYMBOL(leap_second_info, std::chrono::, <chrono>)
 SYMBOL(local_info, std::chrono::, <chrono>)
 SYMBOL(local_seconds, std::chrono::, <chrono>)
 SYMBOL(local_t, std::chrono::, <chrono>)
 SYMBOL(local_time, std::chrono::, <chrono>)
+SYMBOL(local_time_format, std::chrono::, <chrono>)
 SYMBOL(locate_zone, std::chrono::, <chrono>)
+SYMBOL(make12, std::chrono::, <chrono>)
+SYMBOL(make24, std::chrono::, <chrono>)
 SYMBOL(microseconds, std::chrono::, <chrono>)
 SYMBOL(milliseconds, std::chrono::, <chrono>)
 SYMBOL(minutes, std::chrono::, <chrono>)
 SYMBOL(month, std::chrono::, <chrono>)
 SYMBOL(month_day, std::chrono::, <chrono>)
 SYMBOL(month_day_last, std::chrono::, <chrono>)
 SYMBOL(month_weekday, std::chrono::, <chrono>)
 SYMBOL(month_weekday_last, std::chrono::, <chrono>)
 SYMBOL(nanoseconds, std::chrono::, <chrono>)
 SYMBOL(nonexistent_local_time, std::chrono::, <chrono>)
-SYMBOL(round, std::chrono::, <chrono>)
+SYMBOL(parse, std::chrono::, <chrono>)
 SYMBOL(seconds, std::chrono::, <chrono>)
 SYMBOL(steady_clock, std::chrono::, <chrono>)
 SYMBOL(sys_days, std::chrono::, <chrono>)
 SYMBOL(sys_info, std::chrono::, <chrono>)
 SYMBOL(sys_seconds, std::chrono::, <chrono>)
 SYMBOL(sys_time, std::chrono::, <chrono>)
 SYMBOL(system_clock, std::chrono::, <chrono>)
 SYMBOL(tai_clock, std::chrono::, <chrono>)
 SYMBOL(tai_seconds, std::chrono::, <chrono>)
 SYMBOL(tai_time, std::chrono::, <chrono>)
-SYMBOL(time_of_day, std::chrono::, <chrono>)
 SYMBOL(time_point, std::chrono::, <chrono>)
+SYMBOL(time_point_cast, std::chrono::, <chrono>)
 SYMBOL(time_zone, std::chrono::, <chrono>)
+SYMBOL(time_zone_link, std::chrono::, <chrono>)
 SYMBOL(treat_as_floating_point, std::chrono::, <chrono>)
 SYMBOL(treat_as_floating_point_v, std::chrono::, <chrono>)
 SYMBOL(tzdb, std::chrono::, <chrono>)
 SYMBOL(tzdb_list, std::chrono::, <chrono>)
 SYMBOL(utc_clock, std::chrono::, <chrono>)
 SYMBOL(utc_seconds, std::chrono::, <chrono>)
 SYMBOL(utc_time, std::chrono::, <chrono>)
 SYMBOL(weekday, std::chrono::, <chrono>)
 SYMBOL(weekday_indexed, std::chrono::, <chrono>)
 SYMBOL(weekday_last, std::chrono::, <chrono>)
 SYMBOL(year, std::chrono::, <chrono>)
 SYMBOL(year_month, std::chrono::, <chrono>)
 SYMBOL(year_month_day, std::chrono::, <chrono>)
 SYMBOL(year_month_day_last, std::chrono::, <chrono>)
 SYMBOL(year_month_weekday, std::chrono::, <chrono>)
 SYMBOL(year_month_weekday_last, std::chrono::, <chrono>)
+SYMBOL(zoned_seconds, std::chrono::, <chrono>)
 SYMBOL(zoned_time, std::chrono::, <chrono>)
 SYMBOL(zoned_traits, std::chrono::, <chrono>)
 SYMBOL(absolute, std::filesystem::, <filesystem>)
 SYMBOL(canonical, std::filesystem::, <filesystem>)
 SYMBOL(copy, std::filesystem::, <filesystem>)
 SYMBOL(copy_file, std::filesystem::, <filesystem>)
 SYMBOL(copy_options, std::filesystem::, <filesystem>)
 SYMBOL(copy_symlink, std::filesystem::, <filesystem>)

 SYMBOL(equivalent, std::filesystem::, <filesystem>)
 SYMBOL(exists, std::filesystem::, <filesystem>)
 SYMBOL(file_size, std::filesystem::, <filesystem>)
 SYMBOL(file_status, std::filesystem::, <filesystem>)
 SYMBOL(file_time_type, std::filesystem::, <filesystem>)
 SYMBOL(file_type, std::filesystem::, <filesystem>)
 SYMBOL(filesystem_error, std::filesystem::, <filesystem>)
 SYMBOL(hard_link_count, std::filesystem::, <filesystem>)
+SYMBOL(hash_value, std::filesystem::, <filesystem>)
 SYMBOL(is_block_file, std::filesystem::, <filesystem>)
 SYMBOL(is_character_file, std::filesystem::, <filesystem>)
 SYMBOL(is_directory, std::filesystem::, <filesystem>)
 SYMBOL(is_empty, std::filesystem::, <filesystem>)
 SYMBOL(is_fifo, std::filesystem::, <filesystem>)
 SYMBOL(is_other, std::filesystem::, <filesystem>)
 SYMBOL(is_regular_file, std::filesystem::, <filesystem>)
 SYMBOL(is_socket, std::filesystem::, <filesystem>)

 SYMBOL(space_info, std::filesystem::, <filesystem>)
 SYMBOL(status, std::filesystem::, <filesystem>)
 SYMBOL(status_known, std::filesystem::, <filesystem>)
 SYMBOL(symlink_status, std::filesystem::, <filesystem>)
 SYMBOL(temp_directory_path, std::filesystem::, <filesystem>)
 SYMBOL(u8path, std::filesystem::, <filesystem>)
 SYMBOL(weakly_canonical, std::filesystem::, <filesystem>)
 SYMBOL(basic_string, std::pmr::, <string>)
+SYMBOL(cmatch, std::pmr::, <regex>)
 SYMBOL(deque, std::pmr::, <deque>)
 SYMBOL(forward_list, std::pmr::, <forward_list>)
 SYMBOL(get_default_resource, std::pmr::, <memory_resource>)
 SYMBOL(list, std::pmr::, <list>)
 SYMBOL(map, std::pmr::, <map>)
+SYMBOL(match_results, std::pmr::, <regex>)
 SYMBOL(memory_resource, std::pmr::, <memory_resource>)
 SYMBOL(monotonic_buffer_resource, std::pmr::, <memory_resource>)
 SYMBOL(multimap, std::pmr::, <map>)
 SYMBOL(multiset, std::pmr::, <set>)
 SYMBOL(new_delete_resource, std::pmr::, <memory_resource>)
 SYMBOL(null_memory_resource, std::pmr::, <memory_resource>)
 SYMBOL(polymorphic_allocator, std::pmr::, <memory_resource>)
 SYMBOL(pool_options, std::pmr::, <memory_resource>)
 SYMBOL(set, std::pmr::, <set>)
 SYMBOL(set_default_resource, std::pmr::, <memory_resource>)
+SYMBOL(smatch, std::pmr::, <regex>)
+SYMBOL(stacktrace, std::pmr::, <stacktrace>)
 SYMBOL(string, std::pmr::, <string>)
 SYMBOL(synchronized_pool_resource, std::pmr::, <memory_resource>)
 SYMBOL(u16string, std::pmr::, <string>)
 SYMBOL(u32string, std::pmr::, <string>)
+SYMBOL(u8string, std::pmr::, <string>)
 SYMBOL(unordered_map, std::pmr::, <unordered_map>)
 SYMBOL(unordered_multimap, std::pmr::, <unordered_map>)
 SYMBOL(unordered_multiset, std::pmr::, <unordered_set>)
 SYMBOL(unordered_set, std::pmr::, <unordered_set>)
 SYMBOL(unsynchronized_pool_resource, std::pmr::, <memory_resource>)
 SYMBOL(vector, std::pmr::, <vector>)
+SYMBOL(wcmatch, std::pmr::, <regex>)
+SYMBOL(wsmatch, std::pmr::, <regex>)
 SYMBOL(wstring, std::pmr::, <string>)
 SYMBOL(ECMAScript, std::regex_constants::, <regex>)
 SYMBOL(awk, std::regex_constants::, <regex>)
 SYMBOL(basic, std::regex_constants::, <regex>)
 SYMBOL(collate, std::regex_constants::, <regex>)
 SYMBOL(egrep, std::regex_constants::, <regex>)
 SYMBOL(error_backref, std::regex_constants::, <regex>)
 SYMBOL(error_badbrace, std::regex_constants::, <regex>)

clang/tools/include-mapping/cppreference_parser.py

def __init__(self, name, namespace, headers):
     # unqualifed symbol name, e.g. "move"
     self.name = name
     # namespace of the symbol (with trailing "::"), e.g. "std::", "" (global scope)
     # None for C symbols.
     self.namespace = namespace
     # a list of corresponding headers
     self.headers = headers
 
+  def __lt__(self, other):
+    if self.namespace != other.namespace:
+      return self.namespace < other.namespace
+    return self.name < other.name
+
 
 def _HasClass(tag, *classes):
   for c in tag.get('class', []):
     if c in classes:
       return True
   return False
 
 
for symbol_name, symbol_page_path, variant in _ParseIndexPage(f.read()):
       if variant and variant not in variants_for_symbol:
         continue
       path = os.path.join(root_dir, symbol_page_path)
       if os.path.isfile(path):
         results.append((symbol_name,
                       pool.apply_async(_ReadSymbolPage, (path, symbol_name))))
       else:
         sys.stderr.write("Discarding information for symbol: %s. Page %s does not exist.\n" 
-          % (symbol_name, path))                
+          % (symbol_name, path))
 
     # Build map from symbol name to a set of headers.
     symbol_headers = collections.defaultdict(set)
     for symbol_name, lazy_headers in results:
       symbol_headers[symbol_name].update(lazy_headers.get())
 
   symbols = []
   for name, headers in sorted(symbol_headers.items(), key=lambda t : t[0]):
pool = multiprocessing.Pool(
       initializer=lambda: signal.signal(signal.SIGINT, signal.SIG_IGN))
   try:
     for root_dir, page_name, namespace in parse_pages:
       symbols.extend(_GetSymbols(pool, root_dir, page_name, namespace,
                                  variants_to_accept))
   finally:
     pool.terminate()
     pool.join()
-  return symbols
+  return sorted(symbols)

clang/tools/include-mapping/gen_std.py

Caveats and FIXMEs:
   - only symbols directly in "std" namespace are added, we should also add std's
     subnamespace symbols (e.g. chrono).
   - symbols with multiple variants or defined in multiple headers aren't added,
     e.g. std::move, std::swap
 
 Usage:
   1. Install BeautifulSoup dependency, see instruction:
        https://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-beautiful-soup
-  2. Download cppreference offline HTML files (e.g. html_book_20181028.zip) at
+  2. Download cppreference offline HTML files (html_book_20220730.zip in Unofficial Release) at
        https://en.cppreference.com/w/Cppreference:Archives
   3. Unzip the zip file from step 2 (e.g., to a "cppreference" directory). You should
      get a "cppreference/reference" directory.
   4. Run the command:
        // Generate C++ symbols
        python3 gen_std.py -cppreference cppreference/reference -symbols=cpp > StdSymbolMap.inc
-       // Generate C++ removed symbols
-       python3 gen_std.py -cppreference cppreference/reference -symbols=cpp_removed > RemovedSymbolMap.inc
        // Generate C symbols
        python3 gen_std.py -cppreference cppreference/reference -symbols=c > CSymbolMap.inc
 """
 
 
 import cppreference_parser
 import argparse
 import datetime
parse_pages =  [
       # FIXME: index std::placeholders symbols, placeholders.html page is
       # different (which contains one entry for _1, _2, ..., _N), we need special
       # handling.
       (symbol_index_root, "chrono.html", "std::chrono::"),
       (symbol_index_root, "filesystem.html", "std::filesystem::"),
       (symbol_index_root, "pmr.html", "std::pmr::"),
       (symbol_index_root, "regex_constants.html", "std::regex_constants::"),
       (symbol_index_root, "this_thread.html", "std::this_thread::"),
+      # Zombie symbols that were available from the Standard Library, but are
+      # removed in the following standards.
+      (symbol_index_root, "zombie_names.html", "std::"),
     ]
-  elif args.symbols == 'cpp_removed':
-    page_root = os.path.join(args.cppreference, "en", "cpp")
-    symbol_index_root = os.path.join(page_root, "symbol_index")
-    parse_pages = [(symbol_index_root, "zombie_names.html", "std::")]
   elif args.symbols == 'c':
     page_root = os.path.join(args.cppreference, "en", "c")
     symbol_index_root = page_root
     parse_pages = [(page_root, "index.html", None)]  
     
   if not os.path.exists(symbol_index_root):
     exit("Path %s doesn't exist!" % symbol_index_root)