// -*- C++ -*- [std.modules] module std

// Copyright The GNU Toolchain Authors.
//
// 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.

// 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/>.

module;

// stdc++.h doesn't include <execution> because of TBB issues;
// FIXME for now let's avoid the problem by suppressing TBB.
#define _GLIBCXX_USE_TBB_PAR_BACKEND 0

#include <bits/stdc++.h>
#include <execution>

// Module std does include deprecated library interfaces.
#undef __DEPRECATED
#include <strstream>

export module std;

// C library exports are appended from std-clib.cc.in.

// 27.4 <algorithm>
export namespace std
{
  namespace ranges
  {
    using std::ranges::in_found_result;
    using std::ranges::in_fun_result;
    using std::ranges::in_in_out_result;
    using std::ranges::in_in_result;
    using std::ranges::in_out_out_result;
    using std::ranges::in_out_result;
    using std::ranges::min_max_result;
  }
  using std::all_of;
  namespace ranges
  {
    using std::ranges::all_of;
  }
  using std::any_of;
  namespace ranges
  {
    using std::ranges::any_of;
  }
  using std::none_of;
  namespace ranges
  {
    using std::ranges::none_of;
  }
  using std::for_each;
  namespace ranges
  {
    using std::ranges::for_each;
    using std::ranges::for_each_result;
  }
  using std::for_each_n;
  namespace ranges
  {
    using std::ranges::for_each_n;
    using std::ranges::for_each_n_result;
  }
  using std::find;
  using std::find_if;
  using std::find_if_not;
  namespace ranges
  {
    using std::ranges::find;
    using std::ranges::find_if;
    using std::ranges::find_if_not;
  }
  using std::find_end;
  namespace ranges
  {
    using std::ranges::find_end;
  }
  using std::find_first_of;
  namespace ranges
  {
    using std::ranges::find_first_of;
  }
  using std::adjacent_find;
  namespace ranges
  {
    using std::ranges::adjacent_find;
  }
  using std::count;
  using std::count_if;
  namespace ranges
  {
    using std::ranges::count;
    using std::ranges::count_if;
  }
  using std::mismatch;
  namespace ranges
  {
    using std::ranges::mismatch;
    using std::ranges::mismatch_result;
  }
  using std::equal;
  namespace ranges
  {
    using std::ranges::equal;
  }
  using std::is_permutation;
  namespace ranges
  {
    using std::ranges::is_permutation;
  }
  using std::search;
  namespace ranges
  {
    using std::ranges::search;
  }
  using std::search_n;
  namespace ranges
  {
    using std::ranges::search_n;
  }
  namespace ranges
  {}
  using std::copy;
  namespace ranges
  {
    using std::ranges::copy;
    using std::ranges::copy_result;
  }
  using std::copy_n;
  namespace ranges
  {
    using std::ranges::copy_n;
    using std::ranges::copy_n_result;
  }
  using std::copy_if;
  namespace ranges
  {
    using std::ranges::copy_if;
    using std::ranges::copy_if_result;
  }
  using std::copy_backward;
  namespace ranges
  {
    using std::ranges::copy_backward;
    using std::ranges::copy_backward_result;
  }
  using std::move;
  namespace ranges
  {
    using std::ranges::move;
    using std::ranges::move_result;
  }
  using std::move_backward;
  namespace ranges
  {
    using std::ranges::move_backward;
    using std::ranges::move_backward_result;
  }
  using std::swap_ranges;
  namespace ranges
  {
    using std::ranges::swap_ranges;
    using std::ranges::swap_ranges_result;
  }
  using std::iter_swap;
  using std::transform;
  namespace ranges
  {
    using std::ranges::binary_transform_result;
    using std::ranges::transform;
    using std::ranges::unary_transform_result;
  }
  using std::replace;
  using std::replace_if;
  namespace ranges
  {
    using std::ranges::replace;
    using std::ranges::replace_if;
  }
  using std::replace_copy;
  using std::replace_copy_if;
  namespace ranges
  {
    using std::ranges::replace_copy;
    using std::ranges::replace_copy_if;
    using std::ranges::replace_copy_if_result;
    using std::ranges::replace_copy_result;
  }
  using std::fill;
  using std::fill_n;
  namespace ranges
  {
    using std::ranges::fill;
    using std::ranges::fill_n;
  }
  using std::generate;
  using std::generate_n;
  namespace ranges
  {
    using std::ranges::generate;
    using std::ranges::generate_n;
  }
  using std::remove;
  using std::remove_if;
  namespace ranges
  {
    using std::ranges::remove;
    using std::ranges::remove_if;
  }
  using std::remove_copy;
  using std::remove_copy_if;
  namespace ranges
  {
    using std::ranges::remove_copy;
    using std::ranges::remove_copy_if;
    using std::ranges::remove_copy_if_result;
    using std::ranges::remove_copy_result;
  }
  using std::unique;
  namespace ranges
  {
    using std::ranges::unique;
  }
  using std::unique_copy;
  namespace ranges
  {
    using std::ranges::unique_copy;
    using std::ranges::unique_copy_result;
  }
  using std::reverse;
  namespace ranges
  {
    using std::ranges::reverse;
  }
  using std::reverse_copy;
  namespace ranges
  {
    using std::ranges::reverse_copy;
    using std::ranges::reverse_copy_result;
  }
  using std::rotate;
  namespace ranges
  {
    using std::ranges::rotate;
  }
  using std::rotate_copy;
  namespace ranges
  {
    using std::ranges::rotate_copy;
    using std::ranges::rotate_copy_result;
  }
  using std::sample;
  namespace ranges
  {
    using std::ranges::sample;
  }
  using std::shuffle;
  namespace ranges
  {
    using std::ranges::shuffle;
  }
  using std::shift_left;
  namespace ranges
  {}
  using std::shift_right;
  namespace ranges
  {}
  using std::sort;
  namespace ranges
  {
    using std::ranges::sort;
  }
  using std::stable_sort;
  namespace ranges
  {
    using std::ranges::stable_sort;
  }
  using std::partial_sort;
  namespace ranges
  {
    using std::ranges::partial_sort;
  }
  using std::partial_sort_copy;
  namespace ranges
  {
    using std::ranges::partial_sort_copy;
    using std::ranges::partial_sort_copy_result;
  }
  using std::is_sorted;
  using std::is_sorted_until;
  namespace ranges
  {
    using std::ranges::is_sorted;
    using std::ranges::is_sorted_until;
  }
  using std::nth_element;
  namespace ranges
  {
    using std::ranges::nth_element;
  }
  using std::lower_bound;
  namespace ranges
  {
    using std::ranges::lower_bound;
  }
  using std::upper_bound;
  namespace ranges
  {
    using std::ranges::upper_bound;
  }
  using std::equal_range;
  namespace ranges
  {
    using std::ranges::equal_range;
  }
  using std::binary_search;
  namespace ranges
  {
    using std::ranges::binary_search;
  }
  using std::is_partitioned;
  namespace ranges
  {
    using std::ranges::is_partitioned;
  }
  using std::partition;
  namespace ranges
  {
    using std::ranges::partition;
  }
  using std::stable_partition;
  namespace ranges
  {
    using std::ranges::stable_partition;
  }
  using std::partition_copy;
  namespace ranges
  {
    using std::ranges::partition_copy;
    using std::ranges::partition_copy_result;
  }
  using std::partition_point;
  namespace ranges
  {
    using std::ranges::partition_point;
  }
  using std::merge;
  namespace ranges
  {
    using std::ranges::merge;
    using std::ranges::merge_result;
  }
  using std::inplace_merge;
  namespace ranges
  {
    using std::ranges::inplace_merge;
  }
  using std::includes;
  namespace ranges
  {
    using std::ranges::includes;
  }
  using std::set_union;
  namespace ranges
  {
    using std::ranges::set_union;
    using std::ranges::set_union_result;
  }
  using std::set_intersection;
  namespace ranges
  {
    using std::ranges::set_intersection;
    using std::ranges::set_intersection_result;
  }
  using std::set_difference;
  namespace ranges
  {
    using std::ranges::set_difference;
    using std::ranges::set_difference_result;
  }
  using std::set_symmetric_difference;
  namespace ranges
  {
    using std::ranges::set_symmetric_difference;
    using std::ranges::set_symmetric_difference_result;
  }
  using std::push_heap;
  namespace ranges
  {
    using std::ranges::push_heap;
  }
  using std::pop_heap;
  namespace ranges
  {
    using std::ranges::pop_heap;
  }
  using std::make_heap;
  namespace ranges
  {
    using std::ranges::make_heap;
  }
  using std::sort_heap;
  namespace ranges
  {
    using std::ranges::sort_heap;
  }
  using std::is_heap;
  namespace ranges
  {
    using std::ranges::is_heap;
  }
  using std::is_heap_until;
  namespace ranges
  {
    using std::ranges::is_heap_until;
  }
  using std::min;
  namespace ranges
  {
    using std::ranges::min;
  }
  using std::max;
  namespace ranges
  {
    using std::ranges::max;
  }
  using std::minmax;
  namespace ranges
  {
    using std::ranges::minmax;
    using std::ranges::minmax_result;
  }
  using std::min_element;
  namespace ranges
  {
    using std::ranges::min_element;
  }
  using std::max_element;
  namespace ranges
  {
    using std::ranges::max_element;
  }
  using std::minmax_element;
  namespace ranges
  {
    using std::ranges::minmax_element;
    using std::ranges::minmax_element_result;
  }
  using std::clamp;
  namespace ranges
  {
    using std::ranges::clamp;
  }
  using std::lexicographical_compare;
  namespace ranges
  {
    using std::ranges::lexicographical_compare;
  }
  using std::lexicographical_compare_three_way;
  using std::next_permutation;
  namespace ranges
  {
    using std::ranges::next_permutation;
    using std::ranges::next_permutation_result;
  }
  using std::prev_permutation;
  namespace ranges
  {
    using std::ranges::prev_permutation;
    using std::ranges::prev_permutation_result;
  }
  namespace ranges
  {
#if __cpp_lib_ranges_contains
    using ranges::contains;
    using ranges::contains_subrange;
#endif
#if __cpp_lib_ranges_fold
    using ranges::fold_left;
    using ranges::fold_left_first;
    using ranges::fold_left_first_with_iter;
    using ranges::fold_left_with_iter;
    using ranges::fold_right;
    using ranges::fold_right_last;
    using ranges::in_value_result;
    using ranges::out_value_result;
#endif
#if __cpp_lib_ranges_find_last
    using ranges::find_last;
    using ranges::find_last_if;
    using ranges::find_last_if_not;
#endif
  }
}

// 22.7.2 <any>
#if __cpp_lib_any
export namespace std
{
  using std::any;
  using std::any_cast;
  using std::bad_any_cast;
  using std::make_any;
  using std::swap;
}
#endif

// 24.3.2 <array>
export namespace std
{
  using std::array;
  using std::operator==;
  using std::operator<=>;
  using std::get;
  using std::swap;
  using std::to_array;
  using std::tuple_element;
  using std::tuple_size;
}

// 33.5.2 <atomic>
export namespace std
{
  using std::atomic;
  using std::atomic_bool;
  using std::atomic_char;
  using std::atomic_char16_t;
  using std::atomic_char32_t;
  using std::atomic_char8_t;
  using std::atomic_compare_exchange_strong;
  using std::atomic_compare_exchange_strong_explicit;
  using std::atomic_compare_exchange_weak;
  using std::atomic_compare_exchange_weak_explicit;
  using std::atomic_exchange;
  using std::atomic_exchange_explicit;
  using std::atomic_fetch_add;
  using std::atomic_fetch_add_explicit;
  using std::atomic_fetch_and;
  using std::atomic_fetch_and_explicit;
  using std::atomic_fetch_or;
  using std::atomic_fetch_or_explicit;
  using std::atomic_fetch_sub;
  using std::atomic_fetch_sub_explicit;
  using std::atomic_fetch_xor;
  using std::atomic_fetch_xor_explicit;
  using std::atomic_flag;
  using std::atomic_flag_clear;
  using std::atomic_flag_clear_explicit;
  using std::atomic_flag_notify_all;
  using std::atomic_flag_notify_one;
  using std::atomic_flag_test;
  using std::atomic_flag_test_and_set;
  using std::atomic_flag_test_and_set_explicit;
  using std::atomic_flag_test_explicit;
  using std::atomic_flag_wait;
  using std::atomic_flag_wait_explicit;
  using std::atomic_init;
  using std::atomic_int;
  using std::atomic_int16_t;
  using std::atomic_int32_t;
  using std::atomic_int64_t;
  using std::atomic_int8_t;
  using std::atomic_int_fast16_t;
  using std::atomic_int_fast32_t;
  using std::atomic_int_fast64_t;
  using std::atomic_int_fast8_t;
  using std::atomic_int_least16_t;
  using std::atomic_int_least32_t;
  using std::atomic_int_least64_t;
  using std::atomic_int_least8_t;
  using std::atomic_intmax_t;
  using std::atomic_intptr_t;
  using std::atomic_is_lock_free;
  using std::atomic_llong;
  using std::atomic_load;
  using std::atomic_load_explicit;
  using std::atomic_long;
  using std::atomic_notify_all;
  using std::atomic_notify_one;
  using std::atomic_ptrdiff_t;
  using std::atomic_ref;
  using std::atomic_schar;
  using std::atomic_short;
  using std::atomic_signal_fence;
#ifdef __cpp_lib_atomic_lock_free_type_aliases
  using std::atomic_signed_lock_free;
#endif
  using std::atomic_size_t;
  using std::atomic_store;
  using std::atomic_store_explicit;
  using std::atomic_thread_fence;
  using std::atomic_uchar;
  using std::atomic_uint;
  using std::atomic_uint16_t;
  using std::atomic_uint32_t;
  using std::atomic_uint64_t;
  using std::atomic_uint8_t;
  using std::atomic_uint_fast16_t;
  using std::atomic_uint_fast32_t;
  using std::atomic_uint_fast64_t;
  using std::atomic_uint_fast8_t;
  using std::atomic_uint_least16_t;
  using std::atomic_uint_least32_t;
  using std::atomic_uint_least64_t;
  using std::atomic_uint_least8_t;
  using std::atomic_uintmax_t;
  using std::atomic_uintptr_t;
  using std::atomic_ullong;
  using std::atomic_ulong;
#ifdef __cpp_lib_atomic_lock_free_type_aliases
  using std::atomic_unsigned_lock_free;
#endif
  using std::atomic_ushort;
  using std::atomic_wait;
  using std::atomic_wait_explicit;
  using std::atomic_wchar_t;
  using std::kill_dependency;
  using std::memory_order;
  using std::memory_order_acq_rel;
  using std::memory_order_acquire;
  using std::memory_order_consume;
  using std::memory_order_relaxed;
  using std::memory_order_release;
  using std::memory_order_seq_cst;
  // ATOMIC_*_LOCK_FREE not exported
}

// 33.9.3 <barrier>
#if __cpp_lib_barrier
export namespace std
{
  using std::barrier;
}
#endif

// 22.15 <bit>
export namespace std
{
  using std::bit_cast;
  using std::bit_ceil;
  using std::bit_floor;
  using std::bit_width;
  using std::countl_one;
  using std::countl_zero;
  using std::countr_one;
  using std::countr_zero;
  using std::endian;
  using std::has_single_bit;
  using std::popcount;
  using std::rotl;
  using std::rotr;
}

// 22.9 <bitset>
export namespace std
{
  using std::bitset;
  using std::operator&;
  using std::operator|;
  using std::operator^;
  using std::operator>>;
  using std::operator<<;
  using std::hash;
}

// 22.13 <charconv>
export namespace std
{
  using std::chars_format;
  using std::operator&;
  using std::operator&=;
  using std::operator^;
  using std::operator^=;
  using std::operator|;
  using std::operator|=;
  using std::operator~;
  using std::from_chars;
  using std::from_chars_result;
  using std::to_chars;
  using std::to_chars_result;
}

// 29.2 <chrono>
#if __cpp_lib_chrono
export namespace std
{
  namespace chrono
  {
    using std::chrono::duration;
    using std::chrono::time_point;
  }
  using std::common_type;
  namespace chrono
  {
    using std::chrono::duration_values;
    using std::chrono::treat_as_floating_point;
    using std::chrono::treat_as_floating_point_v;
    using std::chrono::operator+;
    using std::chrono::operator-;
    using std::chrono::operator*;
    using std::chrono::operator/;
    using std::chrono::operator%;
    using std::chrono::operator==;
    using std::chrono::operator<;
    using std::chrono::operator>;
    using std::chrono::operator<=;
    using std::chrono::operator>=;
    using std::chrono::operator<=>;
    using std::chrono::ceil;
    using std::chrono::duration_cast;
    using std::chrono::floor;
    using std::chrono::round;
    using std::chrono::operator<<;
    using std::chrono::abs;
    using std::chrono::day;
    using std::chrono::days;
    using std::chrono::file_clock;
    using std::chrono::file_time;
    using std::chrono::hh_mm_ss;
    using std::chrono::high_resolution_clock;
    using std::chrono::hours;
    using std::chrono::is_am;
    using std::chrono::is_pm;
    using std::chrono::last_spec;
    using std::chrono::local_days;
    using std::chrono::local_seconds;
    using std::chrono::local_t;
    using std::chrono::local_time;
    using std::chrono::make12;
    using std::chrono::make24;
    using std::chrono::microseconds;
    using std::chrono::milliseconds;
    using std::chrono::minutes;
    using std::chrono::month;
    using std::chrono::month_day;
    using std::chrono::month_day_last;
    using std::chrono::month_weekday;
    using std::chrono::month_weekday_last;
    using std::chrono::months;
    using std::chrono::nanoseconds;
    using std::chrono::seconds;
    using std::chrono::steady_clock;
    using std::chrono::sys_days;
    using std::chrono::sys_seconds;
    using std::chrono::sys_time;
    using std::chrono::system_clock;
    using std::chrono::time_point_cast;
    using std::chrono::weekday;
    using std::chrono::weekday_indexed;
    using std::chrono::weekday_last;
    using std::chrono::weeks;
    using std::chrono::year;
    using std::chrono::year_month;
    using std::chrono::year_month_day;
    using std::chrono::year_month_day_last;
    using std::chrono::year_month_weekday;
    using std::chrono::year_month_weekday_last;
    using std::chrono::years;
  }
  using std::formatter;
  namespace chrono
  {
    using std::chrono::April;
    using std::chrono::August;
    using std::chrono::December;
    using std::chrono::February;
    using std::chrono::Friday;
    using std::chrono::January;
    using std::chrono::July;
    using std::chrono::June;
    using std::chrono::last;
    using std::chrono::March;
    using std::chrono::May;
    using std::chrono::Monday;
    using std::chrono::November;
    using std::chrono::October;
    using std::chrono::Saturday;
    using std::chrono::September;
    using std::chrono::Sunday;
    using std::chrono::Thursday;
    using std::chrono::Tuesday;
    using std::chrono::Wednesday;
    using chrono::utc_clock;
    using chrono::utc_time;
    using chrono::utc_seconds;
    using chrono::tai_clock;
    using chrono::tai_time;
    using chrono::tai_seconds;
    using chrono::gps_clock;
    using chrono::gps_time;
    using chrono::gps_seconds;
    using chrono::clock_cast;
    using chrono::parse;
    using chrono::from_stream;
    using chrono::clock_time_conversion;
#if __cpp_lib_chrono >= 201907L
    using chrono::tzdb;
    using chrono::tzdb_list;
    using chrono::get_tzdb;
    using chrono::get_tzdb_list;
    using chrono::locate_zone;
    using chrono::current_zone;
    using chrono::reload_tzdb;
    using chrono::remote_version;
    using chrono::nonexistent_local_time;
    using chrono::ambiguous_local_time;
    using chrono::sys_info;
    using chrono::local_info;
    using chrono::choose;
    using chrono::time_zone;
    using chrono::zoned_traits;
    using chrono::zoned_time;
    using chrono::zoned_seconds;
    using chrono::leap_second;
    using chrono::leap_second_info;
    using chrono::get_leap_second_info;
    using chrono::time_zone_link;
    using chrono::local_time_format;
#endif
    using chrono::is_clock;
    using chrono::is_clock_v;
  }
}
export namespace std::inline literals::inline chrono_literals
{
  using std::literals::chrono_literals::operator""h;
  using std::literals::chrono_literals::operator""min;
  using std::literals::chrono_literals::operator""s;
  using std::literals::chrono_literals::operator""ms;
  using std::literals::chrono_literals::operator""us;
  using std::literals::chrono_literals::operator""ns;
  using std::literals::chrono_literals::operator""d;
  using std::literals::chrono_literals::operator""y;
}
export namespace std::chrono {
  using namespace literals::chrono_literals;
}
#endif // __cpp_lib_chrono

// <codecvt>: deprecated C++17, removed C++26
export namespace std
{
  using std::codecvt_mode;
  using std::codecvt_utf16;
  using std::codecvt_utf8;
  using std::codecvt_utf8_utf16;
}

// 17.11.1 <compare>
#if __cpp_lib_three_way_comparison
export namespace std
{
  using std::common_comparison_category;
  using std::common_comparison_category_t;
  using std::compare_three_way;
  using std::compare_three_way_result;
  using std::compare_three_way_result_t;
  using std::is_eq;
  using std::is_gt;
  using std::is_gteq;
  using std::is_lt;
  using std::is_lteq;
  using std::is_neq;
  using std::partial_ordering;
  using std::strong_ordering;
  using std::three_way_comparable;
  using std::three_way_comparable_with;
  using std::weak_ordering;
  using std::compare_partial_order_fallback;
  using std::compare_strong_order_fallback;
  using std::compare_weak_order_fallback;
  using std::partial_order;
  using std::strong_order;
  using std::weak_order;
}
#endif // __cpp_lib_three_way_comparison

// 28.4 <complex>
export namespace std
{
  using std::complex;
  using std::operator+;
  using std::operator-;
  using std::operator*;
  using std::operator/;
  using std::operator==;
  using std::operator>>;
  using std::operator<<;
  using std::abs;
  using std::acos;
  using std::acosh;
  using std::arg;
  using std::asin;
  using std::asinh;
  using std::atan;
  using std::atanh;
  using std::conj;
  using std::cos;
  using std::cosh;
  using std::exp;
  using std::imag;
  using std::log;
  using std::log10;
  using std::norm;
  using std::polar;
  using std::pow;
  using std::proj;
  using std::real;
  using std::sin;
  using std::sinh;
  using std::sqrt;
  using std::tan;
  using std::tanh;
#if __cpp_lib_tuple_like >= 202311L
  using std::tuple_element;
  using std::tuple_element_t;
  using std::tuple_size;
  using std::tuple_size_v;
  using std::get;
#endif
}
export namespace std::inline literals::inline complex_literals
{
  using std::operator""il;
  using std::operator""i;
  using std::operator""if;
}

// 18 <concepts>
#if __cpp_lib_concepts
export namespace std
{
  using std::assignable_from;
  using std::common_reference_with;
  using std::common_with;
  using std::convertible_to;
  using std::derived_from;
  using std::floating_point;
  using std::integral;
  using std::same_as;
  using std::signed_integral;
  using std::unsigned_integral;
  namespace ranges
  {
    using std::ranges::swap;
  }
  using std::constructible_from;
  using std::copy_constructible;
  using std::copyable;
  using std::default_initializable;
  using std::destructible;
  using std::equality_comparable;
  using std::equality_comparable_with;
  using std::equivalence_relation;
  using std::invocable;
  using std::movable;
  using std::move_constructible;
  using std::predicate;
  using std::regular;
  using std::regular_invocable;
  using std::relation;
  using std::semiregular;
  using std::strict_weak_order;
  using std::swappable;
  using std::swappable_with;
  using std::totally_ordered;
  using std::totally_ordered_with;
}
#endif

// 33.7 <condition_variable>
export namespace std
{
  using std::condition_variable;
  using std::condition_variable_any;
  using std::cv_status;
  using std::notify_all_at_thread_exit;
}

// 17.12.2 <coroutine>
#if __cpp_lib_coroutine
export namespace std
{
  using std::coroutine_handle;
  using std::coroutine_traits;
  using std::operator==;
  using std::operator<=>;
  using std::hash;
  using std::noop_coroutine;
  using std::noop_coroutine_handle;
  using std::noop_coroutine_promise;
  using std::suspend_always;
  using std::suspend_never;
}
#endif // __cpp_lib_coroutine

// 22.16 <debugging>
#if __cpp_lib_debugging
export namespace std
{
  using std::breakpoint;
  using std::breakpoint_if_debugging;
  using std::is_debugger_present;
}
#endif

// 24.3 <deque>
export namespace std
{
  using std::deque;
  using std::operator==;
  using std::operator<=>;
  using std::erase;
  using std::erase_if;
  using std::swap;
  namespace pmr
  {
    using std::pmr::deque;
  }
}

// 17.9.2 <exception>
export namespace std
{
  using std::bad_exception;
  using std::current_exception;
  using std::exception;
  using std::exception_ptr;
  using std::get_terminate;
  using std::make_exception_ptr;
  using std::nested_exception;
  using std::rethrow_exception;
  using std::rethrow_if_nested;
  using std::set_terminate;
  using std::terminate;
  using std::terminate_handler;
  using std::throw_with_nested;
  using std::uncaught_exception;
  using std::uncaught_exceptions;
}

// 34.4 <execution>
#if __cpp_lib_execution
export namespace std
{
  using std::is_execution_policy;
  using std::is_execution_policy_v;
  namespace execution
  {
    using std::execution::sequenced_policy;
    using std::execution::parallel_policy;
    using std::execution::parallel_unsequenced_policy;
    using std::execution::unsequenced_policy;
    using std::execution::seq;
    using std::execution::par;
    using std::execution::par_unseq;
    using std::execution::unseq;
  }
#if __cpp_lib_senders
  using std::forwarding_query_t;
  using std::get_allocator_t;
  using std::get_stop_token_t;
  using std::forwarding_query;
  using std::get_allocator;
  using std::get_stop_token;
  using std::stop_token_of_t;
  namespace execution
  {
    using std::execution::get_domain_t;
    using std::execution::get_scheduler_t;
    using std::execution::get_delegation_scheduler_t;
    using std::execution::get_forward_progress_guarantee_t;
    using std::execution::get_completion_scheduler_t;
    using std::execution::get_domain;
    using std::execution::get_scheduler;
    using std::execution::get_delegation_scheduler;
    using std::execution::forward_progress_guarantee;
    using std::execution::get_forward_progress_guarantee;
    using std::execution::get_completion_scheduler;
    using std::execution::empty_env;
    using std::execution::get_env_t;
    using std::execution::get_env;
    using std::execution::env_of_t;
    using std::execution::default_domain;
    using std::execution::scheduler_t;
    using std::execution::scheduler;
    using std::execution::receiver_t;
    using std::execution::receiver;
    using std::execution::receiver_of;
    using std::execution::set_value_t;
    using std::execution::set_error_t;
    using std::execution::set_stopped_t;
    using std::execution::set_value;
    using std::execution::set_error;
    using std::execution::set_stopped;
    using std::execution::operation_state_t;
    using std::execution::operation_state;
    using std::execution::start_t;
    using std::execution::start;
    using std::execution::sender_t;
    using std::execution::sender;
    using std::execution::sender_in;
    using std::execution::sender_to;
    using std::execution::get_completion_signatures_t;
    using std::execution::get_completion_signatures;
    using std::execution::completion_signatures_of_t;
    using std::execution::value_types_of_t;
    using std::execution::error_types_of_t;
    using std::execution::sends_stopped;
    using std::execution::tag_of_t;
    using std::execution::transform_sender;
    using std::execution::transform_env;
    using std::execution::apply_sender;
    using std::execution::connect_t;
    using std::execution::connect;
    using std::execution::connect_result_t;
    using std::execution::just_t;
    using std::execution::just_error_t;
    using std::execution::just_stopped_t;
    using std::execution::schedule_t;
    using std::execution::just;
    using std::execution::just_error;
    using std::execution::just_stopped;
    using std::execution::schedule;
    using std::execution::read_env;
    using std::execution::schedule_result_t;
    using std::execution::sender_adaptor_closure;
    using std::execution::starts_on_t;
    using std::execution::continues_on_t;
    using std::execution::on_t;
    using std::execution::schedule_from_t;
    using std::execution::then_t;
    using std::execution::upon_error_t;
    using std::execution::upon_stopped_t;
    using std::execution::let_value_t;
    using std::execution::let_error_t;
    using std::execution::let_stopped_t;
    using std::execution::bulk_t;
    using std::execution::split_t;
    using std::execution::when_all_t;
    using std::execution::when_all_with_variant_t;
    using std::execution::into_variant_t;
    using std::execution::stopped_as_optional_t;
    using std::execution::stopped_as_error_t;
    using std::execution::starts_on;
    using std::execution::continues_on;
    using std::execution::on;
    using std::execution::schedule_from;
    using std::execution::then;
    using std::execution::upon_error;
    using std::execution::upon_stopped;
    using std::execution::let_value;
    using std::execution::let_error;
    using std::execution::let_stopped;
    using std::execution::bulk;
    using std::execution::split;
    using std::execution::when_all;
    using std::execution::when_all_with_variant;
    using std::execution::into_variant;
    using std::execution::stopped_as_optional;
    using std::execution::stopped_as_error;
    using std::execution::completion_signatures;
    using std::execution::transform_completion_signatures;
    using std::execution::transform_completion_signatures_of;
    using std::execution::run_loop;
  }
  namespace this_thread
  {
    using std::this_thread::sync_wait_t;
    using std::this_thread::sync_wait_with_variant_t;
    using std::this_thread::sync_wait;
    using std::this_thread::sync_wait_with_variant;
  }
#endif // __cpp_lib_senders
}
#endif // __cpp_lib_execution

// 22.8 <expected>
#if __cpp_lib_expected
export namespace std
{
  using std::unexpected;
  using std::bad_expected_access;
  using std::unexpect_t;
  using std::unexpect;
  using std::expected;
}
#endif

// <filesystem>
#if __cpp_lib_filesystem
export namespace std::filesystem
{
  using std::filesystem::begin;
  using std::filesystem::copy_options;
  using std::filesystem::directory_entry;
  using std::filesystem::directory_iterator;
  using std::filesystem::directory_options;
  using std::filesystem::end;
  using std::filesystem::file_status;
  using std::filesystem::file_time_type;
  using std::filesystem::file_type;
  using std::filesystem::filesystem_error;
  using std::filesystem::hash_value;
  using std::filesystem::path;
  using std::filesystem::perm_options;
  using std::filesystem::perms;
  using std::filesystem::recursive_directory_iterator;
  using std::filesystem::space_info;
  using std::filesystem::swap;
  using std::filesystem::operator&;
  using std::filesystem::operator&=;
  using std::filesystem::operator^;
  using std::filesystem::operator^=;
  using std::filesystem::operator|;
  using std::filesystem::operator|=;
  using std::filesystem::operator~;
  using std::filesystem::absolute;
  using std::filesystem::canonical;
  using std::filesystem::copy;
  using std::filesystem::copy_file;
  using std::filesystem::copy_symlink;
  using std::filesystem::create_directories;
  using std::filesystem::create_directory;
  using std::filesystem::create_directory_symlink;
  using std::filesystem::create_hard_link;
  using std::filesystem::create_symlink;
  using std::filesystem::current_path;
  using std::filesystem::equivalent;
  using std::filesystem::exists;
  using std::filesystem::file_size;
  using std::filesystem::hard_link_count;
  using std::filesystem::is_block_file;
  using std::filesystem::is_character_file;
  using std::filesystem::is_directory;
  using std::filesystem::is_empty;
  using std::filesystem::is_fifo;
  using std::filesystem::is_other;
  using std::filesystem::is_regular_file;
  using std::filesystem::is_socket;
  using std::filesystem::is_symlink;
  using std::filesystem::last_write_time;
  using std::filesystem::permissions;
  using std::filesystem::proximate;
  using std::filesystem::read_symlink;
  using std::filesystem::relative;
  using std::filesystem::remove;
  using std::filesystem::remove_all;
  using std::filesystem::rename;
  using std::filesystem::resize_file;
  using std::filesystem::space;
  using std::filesystem::status;
  using std::filesystem::status_known;
  using std::filesystem::symlink_status;
  using std::filesystem::temp_directory_path;
  using std::filesystem::u8path;
  using std::filesystem::weakly_canonical;
}
#endif // __cpp_lib_filesystem

// <flat_map>
#if __cpp_lib_flat_map
export namespace std
{
  using std::flat_map;
  using std::flat_multimap;
  using std::sorted_equivalent;
  using std::sorted_equivalent_t;
  using std::sorted_unique;
  using std::sorted_unique_t;
}
#endif

// <flat_set>
#if __cpp_lib_flat_set
export namespace std
{
  using std::flat_set;
  using std::flat_multiset;
  using std::sorted_equivalent;
  using std::sorted_equivalent_t;
  using std::sorted_unique;
  using std::sorted_unique_t;
}
#endif

// <format>
export namespace std
{
  using std::basic_format_arg;
  using std::basic_format_args;
  using std::basic_format_context;
  using std::basic_format_parse_context;
  using std::basic_format_string;
  using std::format;
  using std::format_args;
  using std::format_context;
  using std::format_error;
  using std::format_parse_context;
  using std::format_string;
  using std::format_to;
  using std::format_to_n;
  using std::format_to_n_result;
  using std::formatted_size;
#if __cpp_lib_format_ranges
  using std::formattable;
#endif
  using std::formatter;
  using std::make_format_args;
  using std::make_wformat_args;
#if __cpp_lib_format >= 202311L // >= C++26
  using std::runtime_format;
#endif
  using std::vformat;
  using std::vformat_to;
  using std::visit_format_arg;
  using std::wformat_args;
  using std::wformat_context;
  using std::wformat_parse_context;
  using std::wformat_string;
#ifdef __cpp_lib_format_ranges
  using std::format_kind;
  using std::range_format;
  using std::range_formatter;
#endif
}

// <forward_list>
export namespace std
{
  using std::forward_list;
  using std::operator==;
  using std::operator<=>;
  using std::erase;
  using std::erase_if;
  using std::swap;
  namespace pmr
  {
    using std::pmr::forward_list;
  }
}

// <fstream>
export namespace std
{
  using std::basic_filebuf;
  using std::basic_fstream;
  using std::basic_ifstream;
  using std::basic_ofstream;
  using std::filebuf;
  using std::fstream;
  using std::ifstream;
  using std::ofstream;
  using std::swap;
  using std::wfilebuf;
  using std::wfstream;
  using std::wifstream;
  using std::wofstream;
}

// <functional>
export namespace std
{
  using std::bind;
  using std::bind_front;
#if __cpp_lib_bind_back
  using std::bind_back;
#endif
  using std::bit_and;
  using std::bit_not;
  using std::bit_or;
  using std::bit_xor;
  using std::compare_three_way;
  using std::cref;
  using std::divides;
  using std::equal_to;
  using std::greater;
  using std::greater_equal;
  using std::identity;
  using std::invoke;
#if __cpp_lib_invoke_r
  using std::invoke_r;
#endif
  using std::is_bind_expression;
  using std::is_bind_expression_v;
  using std::is_placeholder;
  using std::is_placeholder_v;
  using std::less;
  using std::less_equal;
  using std::logical_and;
  using std::logical_not;
  using std::logical_or;
  using std::minus;
  using std::modulus;
#if __cpp_lib_move_only_function
  using std::move_only_function;
#endif
  using std::multiplies;
  using std::negate;
  using std::not_equal_to;
  using std::not_fn;
  using std::plus;
  using std::ref;
  using std::reference_wrapper;
  namespace placeholders
  {
    using std::placeholders::_1;
    using std::placeholders::_10;
    using std::placeholders::_2;
    using std::placeholders::_3;
    using std::placeholders::_4;
    using std::placeholders::_5;
    using std::placeholders::_6;
    using std::placeholders::_7;
    using std::placeholders::_8;
    using std::placeholders::_9;
  }
  using std::bad_function_call;
  using std::function;
  using std::mem_fn;
  using std::swap;
  using std::operator==;
  using std::boyer_moore_horspool_searcher;
  using std::boyer_moore_searcher;
  using std::default_searcher;
  using std::hash;
  namespace ranges
  {
    using std::ranges::equal_to;
    using std::ranges::greater;
    using std::ranges::greater_equal;
    using std::ranges::less;
    using std::ranges::less_equal;
    using std::ranges::not_equal_to;
  }
}

// <future>
export namespace std
{
  using std::future_errc;
  using std::future_status;
  using std::launch;
  using std::operator&;
  using std::operator&=;
  using std::operator^;
  using std::operator^=;
  using std::operator|;
  using std::operator|=;
  using std::operator~;
  using std::async;
  using std::future;
  using std::future_category;
  using std::future_error;
  using std::is_error_code_enum;
  using std::make_error_code;
  using std::make_error_condition;
  using std::packaged_task;
  using std::promise;
  using std::shared_future;
  using std::swap;
  using std::uses_allocator;
}

#if __cpp_lib_generator
export namespace std
{
  using std::generator;
  namespace pmr
  {
    using pmr::generator;
  }
}
#endif

// <hazard_pointer> FIXME

// 17.10.2 <initializer_list>
export namespace std
{
  using std::begin;
  using std::end;
  using std::initializer_list;
}

// <inplace_vector> FIXME

// <iomanip>
export namespace std
{
  using std::get_money;
  using std::get_time;
  using std::put_money;
  using std::put_time;
  using std::quoted;
  using std::resetiosflags;
  using std::setbase;
  using std::setfill;
  using std::setiosflags;
  using std::setprecision;
  using std::setw;
}

// <ios>
export namespace std
{
  using std::fpos;
  using std::operator!=;
  using std::operator-;
  using std::operator==;
  using std::basic_ios;
  using std::boolalpha;
  using std::dec;
  using std::defaultfloat;
  using std::fixed;
  using std::hex;
  using std::hexfloat;
  using std::internal;
  using std::io_errc;
  using std::ios;
  using std::ios_base;
  using std::iostream_category;
  using std::is_error_code_enum;
  using std::left;
  using std::make_error_code;
  using std::make_error_condition;
  using std::noboolalpha;
  using std::noshowbase;
  using std::noshowpoint;
  using std::noshowpos;
  using std::noskipws;
  using std::nounitbuf;
  using std::nouppercase;
  using std::oct;
  using std::right;
  using std::scientific;
  using std::showbase;
  using std::showpoint;
  using std::showpos;
  using std::skipws;
  using std::streamoff;
  using std::streamsize;
  using std::unitbuf;
  using std::uppercase;
  using std::wios;
}

// <iosfwd>
export namespace std
{
  using std::streampos;
  using std::u16streampos;
  using std::u32streampos;
  using std::u8streampos;
  using std::wstreampos;
  using std::basic_osyncstream;
  using std::basic_syncbuf;
  using std::istreambuf_iterator;
  using std::ostreambuf_iterator;
  using std::osyncstream;
  using std::syncbuf;
  using std::wosyncstream;
  using std::wsyncbuf;
  using std::fpos;
}

// <iostream>
export namespace std
{
  using std::cerr;
  using std::cin;
  using std::clog;
  using std::cout;
  using std::wcerr;
  using std::wcin;
  using std::wclog;
  using std::wcout;
}

// <istream>
export namespace std
{
  using std::basic_iostream;
  using std::basic_istream;
  using std::iostream;
  using std::istream;
  using std::wiostream;
  using std::wistream;
  using std::ws;
  using std::operator>>;
}

// <iterator>
export namespace std
{
  using std::incrementable_traits;
  using std::indirectly_readable_traits;
  using std::iter_difference_t;
  using std::iter_reference_t;
  using std::iter_value_t;
  using std::iterator_traits;
  // _Cpo is an implementation detail we can't avoid exposing; if we do the
  // using in ranges directly, it conflicts with any friend functions of the
  // same name, which is why the customization points are in an inline
  // namespace in the first place.
  namespace ranges::inline _Cpo
  {
    using _Cpo::iter_move;
    using _Cpo::iter_swap;
  }
  using std::advance;
  using std::bidirectional_iterator;
  using std::bidirectional_iterator_tag;
  using std::contiguous_iterator;
  using std::contiguous_iterator_tag;
  using std::disable_sized_sentinel_for;
  using std::distance;
  using std::forward_iterator;
  using std::forward_iterator_tag;
  using std::incrementable;
  using std::indirect_binary_predicate;
  using std::indirect_equivalence_relation;
  using std::indirect_result_t;
  using std::indirect_strict_weak_order;
  using std::indirect_unary_predicate;
  using std::indirectly_comparable;
  using std::indirectly_copyable;
  using std::indirectly_copyable_storable;
  using std::indirectly_movable;
  using std::indirectly_movable_storable;
  using std::indirectly_readable;
  using std::indirectly_regular_unary_invocable;
  using std::indirectly_swappable;
  using std::indirectly_unary_invocable;
  using std::indirectly_writable;
  using std::input_iterator;
  using std::input_iterator_tag;
  using std::input_or_output_iterator;
  using std::iter_common_reference_t;
  using std::iter_rvalue_reference_t;
  using std::mergeable;
  using std::next;
  using std::output_iterator;
  using std::output_iterator_tag;
  using std::permutable;
  using std::prev;
  using std::projected;
  using std::random_access_iterator;
  using std::random_access_iterator_tag;
  using std::sentinel_for;
  using std::sized_sentinel_for;
  using std::sortable;
  using std::weakly_incrementable;
  namespace ranges
  {
    using std::ranges::advance;
    using std::ranges::distance;
    using std::ranges::next;
    using std::ranges::prev;
  }
  using std::reverse_iterator;
  using std::operator==;
  using std::operator!=;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::operator<=>;
  using std::operator-;
  using std::operator+;
  using std::back_insert_iterator;
  using std::back_inserter;
  using std::begin;
  using std::cbegin;
  using std::cend;
  using std::common_iterator;
  using std::counted_iterator;
  using std::crbegin;
  using std::crend;
  using std::data;
  using std::default_sentinel;
  using std::default_sentinel_t;
  using std::empty;
  using std::end;
  using std::front_insert_iterator;
  using std::front_inserter;
  using std::insert_iterator;
  using std::inserter;
  using std::istream_iterator;
  using std::istreambuf_iterator;
  using std::iterator;
  using std::make_move_iterator;
  using std::make_reverse_iterator;
  using std::move_iterator;
  using std::move_sentinel;
  using std::ostream_iterator;
  using std::ostreambuf_iterator;
  using std::rbegin;
  using std::rend;
  using std::size;
  using std::ssize;
  using std::unreachable_sentinel;
  using std::unreachable_sentinel_t;
#if __glibcxx_ranges_as_const // >= C++23
  using std::iter_const_reference_t;
  using std::basic_const_iterator;
  using std::const_iterator;
  using std::const_sentinel;
  using std::make_const_iterator;
  using std::make_const_sentinel;
#endif
}
// FIXME these should be friends of __normal_iterator to avoid exporting
// __gnu_cxx.
export namespace __gnu_cxx
{
  using __gnu_cxx::operator==;
  using __gnu_cxx::operator<=>;
  using __gnu_cxx::operator+;
  using __gnu_cxx::operator-;
}

// <latch>
export namespace std
{
  using std::latch;
}

// 17.3.3 <limits> [limits.syn]
export namespace std
{
  using std::float_denorm_style; // deprecated in C++23
  using std::float_round_style;
  using std::numeric_limits;
}

// FIXME <linalg>

// <list>
export namespace std
{
  using std::list;
  using std::operator==;
  using std::operator<=>;
  using std::erase;
  using std::erase_if;
  using std::swap;
  namespace pmr
  {
    using std::pmr::list;
  }
}

// <locale>
export namespace std
{
  using std::codecvt;
  using std::codecvt_base;
  using std::codecvt_byname;
  using std::collate;
  using std::collate_byname;
  using std::ctype;
  using std::ctype_base;
  using std::ctype_byname;
  using std::has_facet;
  using std::isalnum;
  using std::isalpha;
  using std::isblank;
  using std::iscntrl;
  using std::isdigit;
  using std::isgraph;
  using std::islower;
  using std::isprint;
  using std::ispunct;
  using std::isspace;
  using std::isupper;
  using std::isxdigit;
  using std::locale;
  using std::messages;
  using std::messages_base;
  using std::messages_byname;
  using std::money_base;
  using std::money_get;
  using std::money_put;
  using std::moneypunct;
  using std::moneypunct_byname;
  using std::num_get;
  using std::num_put;
  using std::numpunct;
  using std::numpunct_byname;
  using std::time_base;
  using std::time_get;
  using std::time_get_byname;
  using std::time_put;
  using std::time_put_byname;
  using std::tolower;
  using std::toupper;
  using std::use_facet;
  using std::wbuffer_convert;
  using std::wstring_convert;
}

// <map>
export namespace std
{
  using std::map;
  using std::operator==;
  using std::operator<=>;
  using std::erase_if;
  using std::multimap;
  using std::swap;
  namespace pmr
  {
    using std::pmr::map;
    using std::pmr::multimap;
  }
}

// FIXME <mdspan>

// 20.2 <memory>
export namespace std
{
  using std::align;
  using std::allocator;
  using std::allocator_arg;
  using std::allocator_arg_t;
  using std::allocator_traits;
  using std::assume_aligned;
  using std::make_obj_using_allocator;
  using std::pointer_traits;
  using std::to_address;
  using std::uninitialized_construct_using_allocator;
  using std::uses_allocator;
  using std::uses_allocator_construction_args;
  using std::uses_allocator_v;
  using std::operator==;
  using std::addressof;
  using std::uninitialized_default_construct;
  using std::uninitialized_default_construct_n;
  namespace ranges
  {
    using std::ranges::uninitialized_default_construct;
    using std::ranges::uninitialized_default_construct_n;
  }
  using std::uninitialized_value_construct;
  using std::uninitialized_value_construct_n;
  namespace ranges
  {
    using std::ranges::uninitialized_value_construct;
    using std::ranges::uninitialized_value_construct_n;
  }
  using std::uninitialized_copy;
  using std::uninitialized_copy_n;
  namespace ranges
  {
    using std::ranges::uninitialized_copy;
    using std::ranges::uninitialized_copy_n;
    using std::ranges::uninitialized_copy_n_result;
    using std::ranges::uninitialized_copy_result;
  }
  using std::uninitialized_move;
  using std::uninitialized_move_n;
  namespace ranges
  {
    using std::ranges::uninitialized_move;
    using std::ranges::uninitialized_move_n;
    using std::ranges::uninitialized_move_n_result;
    using std::ranges::uninitialized_move_result;
  }
  using std::uninitialized_fill;
  using std::uninitialized_fill_n;
  namespace ranges
  {
    using std::ranges::uninitialized_fill;
    using std::ranges::uninitialized_fill_n;
  }
  using std::construct_at;
  namespace ranges
  {
    using std::ranges::construct_at;
  }
  using std::destroy;
  using std::destroy_at;
  using std::destroy_n;
  namespace ranges
  {
    using std::ranges::destroy;
    using std::ranges::destroy_at;
    using std::ranges::destroy_n;
  }
  using std::default_delete;
  using std::make_unique;
  using std::make_unique_for_overwrite;
  using std::unique_ptr;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::operator<=>;
  using std::operator<<;
  using std::allocate_shared;
  using std::allocate_shared_for_overwrite;
  using std::bad_weak_ptr;
  using std::const_pointer_cast;
  using std::dynamic_pointer_cast;
  using std::make_shared;
  using std::make_shared_for_overwrite;
  using std::reinterpret_pointer_cast;
  using std::shared_ptr;
  using std::static_pointer_cast;
  using std::swap;
  using std::get_deleter;
  using std::atomic_compare_exchange_strong;
  using std::atomic_compare_exchange_strong_explicit;
  using std::atomic_compare_exchange_weak;
  using std::atomic_compare_exchange_weak_explicit;
  using std::atomic_exchange;
  using std::atomic_exchange_explicit;
  using std::atomic_is_lock_free;
  using std::atomic_load;
  using std::atomic_load_explicit;
  using std::atomic_store;
  using std::atomic_store_explicit;
  using std::enable_shared_from_this;
  using std::hash;
  using std::owner_less;
  using std::weak_ptr;
#if __cpp_lib_out_ptr
  using std::out_ptr;
  using std::inout_ptr;
#endif
}

// 20.4 <memory_resource>
export namespace std::pmr
{
  using std::pmr::memory_resource;
  using std::pmr::operator==;
  using std::pmr::get_default_resource;
  using std::pmr::monotonic_buffer_resource;
  using std::pmr::new_delete_resource;
  using std::pmr::null_memory_resource;
  using std::pmr::polymorphic_allocator;
  using std::pmr::pool_options;
  using std::pmr::set_default_resource;
  using std::pmr::synchronized_pool_resource;
  using std::pmr::unsynchronized_pool_resource;
}

// <mutex>
export namespace std
{
  using std::adopt_lock;
  using std::adopt_lock_t;
  using std::call_once;
  using std::defer_lock;
  using std::defer_lock_t;
  using std::lock;
  using std::lock_guard;
  using std::mutex;
  using std::once_flag;
  using std::recursive_mutex;
  using std::recursive_timed_mutex;
  using std::scoped_lock;
  using std::swap;
  using std::timed_mutex;
  using std::try_lock;
  using std::try_to_lock;
  using std::try_to_lock_t;
  using std::unique_lock;
}

// 17.6.2 <new> [new.syn]
export namespace std
{
  using std::align_val_t;
  using std::bad_alloc;
  using std::bad_array_new_length;
  using std::destroying_delete;
  using std::destroying_delete_t;
  using std::get_new_handler;
  using std::hardware_destructive_interference_size;
  using std::hardware_constructive_interference_size;
  using std::launder;
  using std::new_handler;
  using std::nothrow;
  using std::nothrow_t;
  using std::set_new_handler;
}
export
{
  using ::operator new;
  using ::operator delete;
  using ::operator new[];
  using ::operator delete[];
}

// <numbers>
export namespace std::numbers
{
  using std::numbers::e;
  using std::numbers::e_v;
  using std::numbers::egamma;
  using std::numbers::egamma_v;
  using std::numbers::inv_pi;
  using std::numbers::inv_pi_v;
  using std::numbers::inv_sqrt3;
  using std::numbers::inv_sqrt3_v;
  using std::numbers::inv_sqrtpi;
  using std::numbers::inv_sqrtpi_v;
  using std::numbers::ln10;
  using std::numbers::ln10_v;
  using std::numbers::ln2;
  using std::numbers::ln2_v;
  using std::numbers::log10e;
  using std::numbers::log10e_v;
  using std::numbers::log2e;
  using std::numbers::log2e_v;
  using std::numbers::phi;
  using std::numbers::phi_v;
  using std::numbers::pi;
  using std::numbers::pi_v;
  using std::numbers::sqrt2;
  using std::numbers::sqrt2_v;
  using std::numbers::sqrt3;
  using std::numbers::sqrt3_v;
}

// <numeric>
export namespace std
{
  using std::accumulate;
  using std::adjacent_difference;
  using std::exclusive_scan;
  using std::inclusive_scan;
  using std::inner_product;
  using std::iota;
  using std::partial_sum;
  using std::reduce;
  using std::transform_exclusive_scan;
  using std::transform_inclusive_scan;
  using std::transform_reduce;
  using std::gcd;
  using std::lcm;
  using std::midpoint;
#if __cpp_lib_ranges_iota
  namespace ranges { using ranges::iota; }
#endif
#if __cpp_lib_saturation_arithmetic
  using std::add_sat;
  using std::sub_sat;
  using std::mul_sat;
  using std::div_sat;
  using std::saturate_cast;
#endif
}

// <optional>
export namespace std
{
  using std::bad_optional_access;
  using std::nullopt;
  using std::nullopt_t;
  using std::optional;
  using std::operator==;
  using std::operator!=;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::operator<=>;
  using std::hash;
  using std::make_optional;
  using std::swap;
}

// <ostream>
export namespace std
{
  using std::basic_ostream;
  using std::endl;
  using std::ends;
  using std::flush;
  using std::ostream;
  using std::wostream;
  using std::operator<<;
  using std::emit_on_flush;
  using std::noemit_on_flush;
  using std::flush_emit;
}

// <print>
#if __cpp_lib_print
export namespace std
{
  using std::print;
  using std::println;
  using std::vprint_unicode;
  //FIXME using std::vprint_unicode_buffered;
  using std::vprint_nonunicode;
  //FIXME using std::vprint_nonunicode_buffered;
}
#endif

// <queue>
export namespace std
{
  using std::queue;
  using std::operator==;
  using std::operator!=;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::operator<=>;
  using std::priority_queue;
  using std::swap;
  using std::uses_allocator;
}

// <random>
export namespace std
{
  using std::bernoulli_distribution;
  using std::binomial_distribution;
  using std::cauchy_distribution;
  using std::chi_squared_distribution;
  using std::default_random_engine;
  using std::discard_block_engine;
  using std::discrete_distribution;
  using std::exponential_distribution;
  using std::extreme_value_distribution;
  using std::fisher_f_distribution;
  using std::gamma_distribution;
  using std::generate_canonical;
  using std::geometric_distribution;
  using std::independent_bits_engine;
  using std::knuth_b;
  using std::linear_congruential_engine;
  using std::lognormal_distribution;
  using std::mersenne_twister_engine;
  using std::minstd_rand;
  using std::minstd_rand0;
  using std::mt19937;
  using std::mt19937_64;
  using std::negative_binomial_distribution;
  using std::normal_distribution;
  using std::piecewise_constant_distribution;
  using std::piecewise_linear_distribution;
  using std::poisson_distribution;
  using std::random_device;
  using std::ranlux24;
  using std::ranlux24_base;
  using std::ranlux48;
  using std::ranlux48_base;
  using std::seed_seq;
  using std::shuffle_order_engine;
  using std::student_t_distribution;
  using std::subtract_with_carry_engine;
  using std::uniform_int_distribution;
  using std::uniform_random_bit_generator;
  using std::uniform_real_distribution;
  using std::weibull_distribution;
}

// <ranges>
export namespace std
{
  namespace ranges
  {
    using std::ranges::begin;
    using std::ranges::cbegin;
    using std::ranges::cdata;
    using std::ranges::cend;
    using std::ranges::crbegin;
    using std::ranges::crend;
    using std::ranges::data;
    using std::ranges::empty;
    using std::ranges::end;
    using std::ranges::rbegin;
    using std::ranges::rend;
    using std::ranges::size;
    using std::ranges::ssize;
    using std::ranges::bidirectional_range;
    using std::ranges::borrowed_range;
    using std::ranges::common_range;
    using std::ranges::contiguous_range;
    using std::ranges::disable_sized_range;
    using std::ranges::enable_borrowed_range;
    using std::ranges::enable_view;
    using std::ranges::forward_range;
    using std::ranges::get;
    using std::ranges::input_range;
    using std::ranges::iterator_t;
    using std::ranges::output_range;
    using std::ranges::random_access_range;
    using std::ranges::range;
    using std::ranges::range_common_reference_t;
    using std::ranges::range_difference_t;
    using std::ranges::range_reference_t;
    using std::ranges::range_rvalue_reference_t;
    using std::ranges::range_size_t;
    using std::ranges::range_value_t;
    using std::ranges::sentinel_t;
    using std::ranges::sized_range;
    using std::ranges::subrange;
    using std::ranges::subrange_kind;
    using std::ranges::view;
    using std::ranges::view_base;
    using std::ranges::view_interface;
    using std::ranges::viewable_range;
  }
  using std::ranges::get;
  namespace ranges
  {
    using std::ranges::borrowed_iterator_t;
    using std::ranges::borrowed_subrange_t;
    using std::ranges::dangling;
    using std::ranges::empty_view;
    namespace views
    {
      using std::ranges::views::empty;
    }
    using std::ranges::single_view;
    namespace views
    {
      using std::ranges::views::single;
    }
    using std::ranges::iota_view;
    namespace views
    {
      using std::ranges::views::iota;
    }
    using std::ranges::basic_istream_view;
    using std::ranges::istream_view;
    using std::ranges::wistream_view;
    namespace views
    {
      using std::ranges::views::istream;
    }
    namespace views
    {
      using std::ranges::views::all;
      using std::ranges::views::all_t;
    }
    using std::ranges::filter_view;
    using std::ranges::owning_view;
    using std::ranges::ref_view;
    namespace views
    {
      using std::ranges::views::filter;
    }
    using std::ranges::transform_view;
    namespace views
    {
      using std::ranges::views::transform;
    }
    using std::ranges::take_view;
    namespace views
    {
      using std::ranges::views::take;
    }
    using std::ranges::take_while_view;
    namespace views
    {
      using std::ranges::views::take_while;
    }
    using std::ranges::drop_view;
    namespace views
    {
      using std::ranges::views::drop;
    }
    using std::ranges::drop_while_view;
    namespace views
    {
      using std::ranges::views::drop_while;
    }
    using std::ranges::join_view;
    namespace views
    {
      using std::ranges::views::join;
    }
    using std::ranges::lazy_split_view;
    using std::ranges::split_view;
    namespace views
    {
      using std::ranges::views::lazy_split;
      using std::ranges::views::split;
    }
    namespace views
    {
      using std::ranges::views::counted;
    }
    using std::ranges::common_view;
    namespace views
    {
      using std::ranges::views::common;
    }
    using std::ranges::reverse_view;
    namespace views
    {
      using std::ranges::views::reverse;
    }
    using std::ranges::elements_view;
    using std::ranges::keys_view;
    using std::ranges::values_view;
    namespace views
    {
      using std::ranges::views::elements;
      using std::ranges::views::keys;
      using std::ranges::views::values;
    }
#if __cpp_lib_ranges >= 202202L
    using ranges::range_adaptor_closure;
#endif
  }
  namespace views = ranges::views;
  using std::tuple_element;
  using std::tuple_size;
  namespace ranges
  {
#if __glibcxx_ranges_as_const // >= C++23
    using ranges::constant_range;
    using ranges::const_iterator_t;
    using ranges::const_sentinel_t;
    using ranges::range_const_reference_t;
    using ranges::as_const_view;
    namespace views { using views::as_const; }
#endif
#ifdef __glibcxx_generator  // C++ >= 23 && __glibcxx_coroutine
    using ranges::elements_of;
#endif
#ifdef __cpp_lib_ranges_as_rvalue // C++ >= 23
    using ranges::as_rvalue_view;
    namespace views { using views::as_rvalue; }
#endif
#ifdef __cpp_lib_ranges_chunk // C++ >= 23
    using ranges::chunk_view;
    namespace views { using views::chunk; }
#endif
#ifdef __cpp_lib_ranges_slide // C++ >= 23
    using ranges::slide_view;
    namespace views { using views::slide; }
#endif
#ifdef __cpp_lib_ranges_zip // C++ >= 23
    using ranges::zip_view;
    using ranges::zip_transform_view;
    using ranges::adjacent_view;
    using ranges::adjacent_transform_view;
    namespace views {
      using views::zip;
      using views::zip_transform;
      using views::adjacent;
      using views::adjacent_transform;
      using views::pairwise;
      using views::pairwise_transform;
    }
#endif
#ifdef __cpp_lib_ranges_chunk_by // C++ >= 23
    using ranges::chunk_by_view;
    namespace views { using views::chunk_by; }
#endif
#ifdef __cpp_lib_ranges_join_with // C++ >= 23
    using ranges::join_with_view;
    namespace views { using views::join_with; }
#endif
#ifdef __cpp_lib_ranges_repeat // C++ >= 23
    using ranges::repeat_view;
    namespace views { using views::repeat; }
#endif
#ifdef __cpp_lib_ranges_stride // C++ >= 23
    using ranges::stride_view;
    namespace views { using views::stride; }
#endif
#ifdef __cpp_lib_ranges_cartesian_product // C++ >= 23
    using ranges::cartesian_product_view;
    namespace views { using views::cartesian_product; }
#endif
#ifdef __cpp_lib_ranges_enumerate // C++ >= 23
    using ranges::enumerate_view;
    namespace views { using views::enumerate; }
#endif
#if __cpp_lib_ranges_concat // C++ >= C++26
    using ranges::concat_view;
    namespace views { using views::concat; }
#endif
#if __cpp_lib_ranges_cache_latest // C++ >= C++26
    using ranges::cache_latest_view;
    namespace views { using views::cache_latest; }
#endif
#if __glibcxx_ranges_to_input // C++ >= 26
    using ranges::to_input_view;
    namespace views { using views::to_input; }
#endif
  }
#if __glibcxx_ranges_to_container // C++ >= 23
  namespace ranges { using ranges::to; }
  using std::from_range_t;
  using std::from_range;
#endif
}

// <ratio>
export namespace std
{
  using std::atto;
  using std::centi;
  using std::deca;
  using std::deci;
  using std::exa;
  using std::femto;
  using std::giga;
  using std::hecto;
  using std::kilo;
  using std::mega;
  using std::micro;
  using std::milli;
  using std::nano;
  using std::peta;
  using std::pico;
  using std::ratio;
  using std::ratio_add;
  using std::ratio_divide;
  using std::ratio_equal;
  using std::ratio_equal_v;
  using std::ratio_greater;
  using std::ratio_greater_equal;
  using std::ratio_greater_equal_v;
  using std::ratio_greater_v;
  using std::ratio_less;
  using std::ratio_less_equal;
  using std::ratio_less_equal_v;
  using std::ratio_less_v;
  using std::ratio_multiply;
  using std::ratio_not_equal;
  using std::ratio_not_equal_v;
  using std::ratio_subtract;
  using std::tera;
}

// FIXME <rcu>

// <regex>
export namespace std
{
  namespace regex_constants
  {
    using std::regex_constants::error_type;
    using std::regex_constants::match_flag_type;
    using std::regex_constants::syntax_option_type;
    using std::regex_constants::operator&;
    using std::regex_constants::operator&=;
    using std::regex_constants::operator^;
    using std::regex_constants::operator^=;
    using std::regex_constants::operator|;
    using std::regex_constants::operator|=;
    using std::regex_constants::operator~;
  }
  using std::basic_regex;
  using std::csub_match;
  using std::regex;
  using std::regex_error;
  using std::regex_traits;
  using std::ssub_match;
  using std::sub_match;
  using std::swap;
  using std::wcsub_match;
  using std::wregex;
  using std::wssub_match;
  using std::operator==;
  using std::operator<=>;
  using std::operator<<;
  using std::cmatch;
  using std::cregex_iterator;
  using std::cregex_token_iterator;
  using std::match_results;
  using std::regex_iterator;
  using std::regex_match;
  using std::regex_replace;
  using std::regex_search;
  using std::regex_token_iterator;
  using std::smatch;
  using std::sregex_iterator;
  using std::sregex_token_iterator;
  using std::wcmatch;
  using std::wcregex_iterator;
  using std::wcregex_token_iterator;
  using std::wsmatch;
  using std::wsregex_iterator;
  using std::wsregex_token_iterator;
  namespace pmr
  {
    using std::pmr::cmatch;
    using std::pmr::match_results;
    using std::pmr::smatch;
    using std::pmr::wcmatch;
    using std::pmr::wsmatch;
  }
}

// 20.5 <scoped_allocator>
export namespace std
{
  using std::scoped_allocator_adaptor;
  using std::operator==;
}

// <semaphore>
export namespace std
{
  using std::binary_semaphore;
  using std::counting_semaphore;
}

// <set>
export namespace std
{
  using std::set;
  using std::operator==;
  using std::operator<=>;
  using std::erase_if;
  using std::multiset;
  using std::swap;
  namespace pmr
  {
    using std::pmr::multiset;
    using std::pmr::set;
  }
}

// <shared_mutex>
export namespace std
{
  using std::shared_lock;
  using std::shared_mutex;
  using std::shared_timed_mutex;
  using std::swap;
}

// 17.8.1 <source_location>
export namespace std
{
  using std::source_location;
}

// <span>
export namespace std
{
  using std::dynamic_extent;
  using std::span;
  namespace ranges
  {
    using std::ranges::enable_borrowed_range;
    using std::ranges::enable_view;
  }
  using std::as_bytes;
  using std::as_writable_bytes;
}

#if __cpp_lib_spanstream
// <spanstream>
export namespace std
{
  using std::basic_spanbuf;
  using std::spanbuf;
  using std::wspanbuf;
  using std::basic_ispanstream;
  using std::ispanstream;
  using std::wispanstream;
  using std::basic_ospanstream;
  using std::ospanstream;
  using std::wospanstream;
  using std::basic_spanstream;
  using std::spanstream;
  using std::wspanstream;
}
#endif

// <sstream>
export namespace std
{
  using std::basic_istringstream;
  using std::basic_ostringstream;
  using std::basic_stringbuf;
  using std::basic_stringstream;
  using std::istringstream;
  using std::ostringstream;
  using std::stringbuf;
  using std::stringstream;
  using std::swap;
  using std::wistringstream;
  using std::wostringstream;
  using std::wstringbuf;
  using std::wstringstream;
}

// <stack>
export namespace std
{
  using std::stack;
  using std::operator==;
  using std::operator!=;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::operator<=>;
  using std::swap;
  using std::uses_allocator;
}

// 19.6 <stacktrace>
#if __cpp_lib_stacktrace
export namespace std
{
  using std::stacktrace_entry;
  using std::basic_stacktrace;
  using std::stacktrace;
  using std::swap;
  using std::to_string;
  using std::operator<<;
  using std::formatter;
  namespace pmr
  {
    using std::pmr::stacktrace;
  }
  using std::hash;
}
#endif

// 19.2 <stdexcept>
export namespace std
{
  using std::domain_error;
  using std::invalid_argument;
  using std::length_error;
  using std::logic_error;
  using std::out_of_range;
  using std::overflow_error;
  using std::range_error;
  using std::runtime_error;
  using std::underflow_error;
}

// 17.4.2 <stdfloat>
export namespace std
{
#ifdef __STDCPP_FLOAT16_T__
  using std::float16_t;
#endif
#ifdef __STDCPP_FLOAT32_T__
  using std::float32_t;
#endif
#ifdef __STDCPP_FLOAT64_T__
  using std::float64_t;
#endif
#ifdef __STDCPP_FLOAT128_T__
  using std::float128_t;
#endif
#ifdef __STDCPP_BFLOAT16_T__
  using std::bfloat16_t;
#endif
}

// <stop_token>
#if __cpp_lib_jthread
export namespace std
{
  using std::stop_token;
  using std::stop_source;
  using std::nostopstate_t;
  using std::nostopstate;
  using std::stop_callback;
#if __cpp_lib_senders
  using std::never_stop_token;
  using std::inplace_stop_token;
  using std::inplace_stop_source;
  using std::inplace_stop_callback;
  using std::stop_callback_for;
#endif
}
#endif

// <streambuf>
export namespace std
{
  using std::basic_streambuf;
  using std::streambuf;
  using std::wstreambuf;
}

// <string>
export namespace std
{
  using std::basic_string;
  using std::char_traits;
  using std::operator+;
  using std::operator==;
  using std::operator<=>;
  using std::swap;
  using std::operator>>;
  using std::operator<<;
  using std::erase;
  using std::erase_if;
  using std::getline;
  using std::stod;
  using std::stof;
  using std::stoi;
  using std::stol;
  using std::stold;
  using std::stoll;
  using std::stoul;
  using std::stoull;
  using std::string;
  using std::to_string;
  using std::to_wstring;
  using std::u16string;
  using std::u32string;
  using std::u8string;
  using std::wstring;
  namespace pmr
  {
    using std::pmr::basic_string;
    using std::pmr::string;
    using std::pmr::u16string;
    using std::pmr::u32string;
    using std::pmr::u8string;
    using std::pmr::wstring;
  }
  using std::hash;
}
export namespace std::inline literals::inline string_literals
{
  using std::operator""s;
}

// <string_view>
export namespace std
{
  using std::basic_string_view;
  namespace ranges
  {
    using std::ranges::enable_borrowed_range;
    using std::ranges::enable_view;
  }
  using std::operator==;
  using std::operator<=>;
  using std::operator<<;
  using std::hash;
  using std::string_view;
  using std::u16string_view;
  using std::u32string_view;
  using std::u8string_view;
  using std::wstring_view;
}
export namespace std::inline literals::inline string_view_literals
{
  using string_view_literals::operator""sv;
}

// <strstream>: deprecated C++98, removed C++26
export namespace std
{
  using std::istrstream;
  using std::ostrstream;
  using std::strstream;
  using std::strstreambuf;
}

// <syncstream>
export namespace std
{
  using std::basic_syncbuf;
  using std::swap;
  using std::basic_osyncstream;
  using std::osyncstream;
  using std::syncbuf;
  using std::wosyncstream;
  using std::wsyncbuf;
}

// 19.5 <system_error>
export namespace std
{
  using std::errc;
  using std::error_category;
  using std::error_code;
  using std::error_condition;
  using std::generic_category;
  using std::is_error_code_enum;
  using std::is_error_condition_enum;
  using std::make_error_code;
  using std::system_category;
  using std::system_error;
  using std::operator<<;
  using std::make_error_condition;
  using std::operator==;
  using std::operator<=>;
  using std::hash;
  using std::is_error_code_enum_v;
  using std::is_error_condition_enum_v;
}

// <text_encoding>
#if __cpp_lib_text_encoding
export namespace std
{
  using std::text_encoding;
}
#endif

// <thread>
export namespace std
{
  using std::swap;
  using std::thread;
  using std::jthread;
  namespace this_thread
  {
    using std::this_thread::get_id;
    using std::this_thread::sleep_for;
    using std::this_thread::sleep_until;
    using std::this_thread::yield;
  }
  using std::operator==;
  using std::operator<=>;
  using std::operator<<;
  using std::hash;
}

// <tuple>
export namespace std
{
  using std::apply;
  using std::forward_as_tuple;
  using std::get;
  using std::ignore;
  using std::make_from_tuple;
  using std::make_tuple;
  using std::tie;
  using std::tuple;
  using std::tuple_cat;
  using std::tuple_element;
  using std::tuple_element_t;
  using std::tuple_size;
  using std::operator==;
  using std::operator<=>;
  using std::swap;
  using std::tuple_size_v;
  using std::uses_allocator;
}

// <type_traits>
export namespace std
{
  using std::add_const;
  using std::add_const_t;
  using std::add_cv;
  using std::add_cv_t;
  using std::add_lvalue_reference;
  using std::add_lvalue_reference_t;
  using std::add_pointer;
  using std::add_pointer_t;
  using std::add_rvalue_reference;
  using std::add_rvalue_reference_t;
  using std::add_volatile;
  using std::add_volatile_t;
  using std::aligned_storage;
  using std::aligned_storage_t;
  using std::aligned_union;
  using std::aligned_union_t;
  using std::alignment_of;
  using std::alignment_of_v;
  using std::basic_common_reference;
  using std::bool_constant;
  using std::common_reference;
  using std::common_reference_t;
  using std::common_type;
  using std::common_type_t;
  using std::conditional;
  using std::conditional_t;
  using std::conjunction;
  using std::conjunction_v;
  using std::decay;
  using std::decay_t;
  using std::disjunction;
  using std::disjunction_v;
  using std::enable_if;
  using std::enable_if_t;
  using std::extent;
  using std::extent_v;
  using std::false_type;
  using std::has_unique_object_representations;
  using std::has_unique_object_representations_v;
  using std::has_virtual_destructor;
  using std::has_virtual_destructor_v;
  using std::integral_constant;
  using std::invoke_result;
  using std::invoke_result_t;
  using std::is_abstract;
  using std::is_abstract_v;
  using std::is_aggregate;
  using std::is_aggregate_v;
  using std::is_arithmetic;
  using std::is_arithmetic_v;
  using std::is_array;
  using std::is_array_v;
  using std::is_assignable;
  using std::is_assignable_v;
  using std::is_base_of;
  using std::is_base_of_v;
  using std::is_bounded_array;
  using std::is_bounded_array_v;
  using std::is_class;
  using std::is_class_v;
  using std::is_compound;
  using std::is_compound_v;
  using std::is_const;
  using std::is_const_v;
  using std::is_constant_evaluated;
  using std::is_constructible;
  using std::is_constructible_v;
  using std::is_convertible;
  using std::is_convertible_v;
  using std::is_copy_assignable;
  using std::is_copy_assignable_v;
  using std::is_copy_constructible;
  using std::is_copy_constructible_v;
  using std::is_default_constructible;
  using std::is_default_constructible_v;
  using std::is_destructible;
  using std::is_destructible_v;
  using std::is_empty;
  using std::is_empty_v;
  using std::is_enum;
  using std::is_enum_v;
  using std::is_final;
  using std::is_final_v;
  using std::is_floating_point;
  using std::is_floating_point_v;
  using std::is_function;
  using std::is_function_v;
  using std::is_fundamental;
  using std::is_fundamental_v;
  using std::is_integral;
  using std::is_integral_v;
  using std::is_invocable;
  using std::is_invocable_r;
  using std::is_invocable_r_v;
  using std::is_invocable_v;
  using std::is_lvalue_reference;
  using std::is_lvalue_reference_v;
  using std::is_member_function_pointer;
  using std::is_member_function_pointer_v;
  using std::is_member_object_pointer;
  using std::is_member_object_pointer_v;
  using std::is_member_pointer;
  using std::is_member_pointer_v;
  using std::is_move_assignable;
  using std::is_move_assignable_v;
  using std::is_move_constructible;
  using std::is_move_constructible_v;
  using std::is_nothrow_assignable;
  using std::is_nothrow_assignable_v;
  using std::is_nothrow_constructible;
  using std::is_nothrow_constructible_v;
  using std::is_nothrow_convertible;
  using std::is_nothrow_convertible_v;
  using std::is_nothrow_copy_assignable;
  using std::is_nothrow_copy_assignable_v;
  using std::is_nothrow_copy_constructible;
  using std::is_nothrow_copy_constructible_v;
  using std::is_nothrow_default_constructible;
  using std::is_nothrow_default_constructible_v;
  using std::is_nothrow_destructible;
  using std::is_nothrow_destructible_v;
  using std::is_nothrow_invocable;
  using std::is_nothrow_invocable_r;
  using std::is_nothrow_invocable_r_v;
  using std::is_nothrow_invocable_v;
  using std::is_nothrow_move_assignable;
  using std::is_nothrow_move_assignable_v;
  using std::is_nothrow_move_constructible;
  using std::is_nothrow_move_constructible_v;
  using std::is_nothrow_swappable;
  using std::is_nothrow_swappable_v;
  using std::is_nothrow_swappable_with;
  using std::is_nothrow_swappable_with_v;
  using std::is_null_pointer;
  using std::is_null_pointer_v;
  using std::is_object;
  using std::is_object_v;
  using std::is_pod;
  using std::is_pod_v;
  using std::is_pointer;
  using std::is_pointer_v;
  using std::is_polymorphic;
  using std::is_polymorphic_v;
  using std::is_reference;
  using std::is_reference_v;
  using std::is_rvalue_reference;
  using std::is_rvalue_reference_v;
  using std::is_same;
  using std::is_same_v;
  using std::is_scalar;
  using std::is_scalar_v;
  using std::is_signed;
  using std::is_signed_v;
  using std::is_standard_layout;
  using std::is_standard_layout_v;
  using std::is_swappable;
  using std::is_swappable_v;
  using std::is_swappable_with;
  using std::is_swappable_with_v;
  using std::is_trivial;
  using std::is_trivial_v;
  using std::is_trivially_assignable;
  using std::is_trivially_assignable_v;
  using std::is_trivially_constructible;
  using std::is_trivially_constructible_v;
  using std::is_trivially_copy_assignable;
  using std::is_trivially_copy_assignable_v;
  using std::is_trivially_copy_constructible;
  using std::is_trivially_copy_constructible_v;
  using std::is_trivially_copyable;
  using std::is_trivially_copyable_v;
  using std::is_trivially_default_constructible;
  using std::is_trivially_default_constructible_v;
  using std::is_trivially_destructible;
  using std::is_trivially_destructible_v;
  using std::is_trivially_move_assignable;
  using std::is_trivially_move_assignable_v;
  using std::is_trivially_move_constructible;
  using std::is_trivially_move_constructible_v;
  using std::is_unbounded_array;
  using std::is_unbounded_array_v;
  using std::is_union;
  using std::is_union_v;
  using std::is_unsigned;
  using std::is_unsigned_v;
#if __cpp_lib_is_virtual_base_of
  using std::is_virtual_base_of;
  using std::is_virtual_base_of_v;
#endif
  using std::is_void;
  using std::is_void_v;
  using std::is_volatile;
  using std::is_volatile_v;
  using std::make_signed;
  using std::make_signed_t;
  using std::make_unsigned;
  using std::make_unsigned_t;
  using std::negation;
  using std::negation_v;
  using std::rank;
  using std::rank_v;
  using std::remove_all_extents;
  using std::remove_all_extents_t;
  using std::remove_const;
  using std::remove_const_t;
  using std::remove_cv;
  using std::remove_cv_t;
  using std::remove_cvref;
  using std::remove_cvref_t;
  using std::remove_extent;
  using std::remove_extent_t;
  using std::remove_pointer;
  using std::remove_pointer_t;
  using std::remove_reference;
  using std::remove_reference_t;
  using std::remove_volatile;
  using std::remove_volatile_t;
  using std::true_type;
  using std::type_identity;
  using std::type_identity_t;
  using std::underlying_type;
  using std::underlying_type_t;
  using std::unwrap_ref_decay;
  using std::unwrap_ref_decay_t;
  using std::unwrap_reference;
  using std::unwrap_reference_t;
  using std::void_t;
#if __cpp_lib_reference_from_temporary
  using std::reference_converts_from_temporary;
  using std::reference_converts_from_temporary_v;
  using std::reference_constructs_from_temporary;
  using std::reference_constructs_from_temporary_v;
#endif
#if __cpp_lib_is_layout_compatible
  using std::is_corresponding_member;
  using std::is_layout_compatible;
  using std::is_layout_compatible_v;
#endif
#if __cpp_lib_is_pointer_interconvertible
  using std::is_pointer_interconvertible_base_of;
  using std::is_pointer_interconvertible_base_of_v;
  using std::is_pointer_interconvertible_with_class;
#endif
}

// <typeindex>
export namespace std
{
  using std::hash;
  using std::type_index;
}

// 17.7.2 <typeinfo> [typeinfo.syn]
export namespace std
{
  using std::bad_cast;
  using std::bad_typeid;
  using std::type_info;
}

// <unordered_map>
export namespace std
{
  using std::unordered_map;
  using std::unordered_multimap;
  using std::operator==;
  using std::erase_if;
  using std::swap;
  namespace pmr
  {
    using std::pmr::unordered_map;
    using std::pmr::unordered_multimap;
  }
}

// <unordered_set>
export namespace std
{
  using std::unordered_multiset;
  using std::unordered_set;
  using std::operator==;
  using std::erase_if;
  using std::swap;
  namespace pmr
  {
    using std::pmr::unordered_multiset;
    using std::pmr::unordered_set;
  }
}

// <utility>
export namespace std
{
  using std::as_const;
  using std::cmp_equal;
  using std::cmp_greater;
  using std::cmp_greater_equal;
  using std::cmp_less;
  using std::cmp_less_equal;
  using std::cmp_not_equal;
  using std::declval;
  using std::exchange;
  using std::forward;
#if __cpp_lib_forward_like
  using std::forward_like;
#endif
  using std::in_range;
  using std::index_sequence;
  using std::index_sequence_for;
  using std::integer_sequence;
  using std::make_index_sequence;
  using std::make_integer_sequence;
  using std::move;
  using std::move_if_noexcept;
  using std::pair;
  using std::swap;
  using std::operator==;
  using std::operator<=>;
  using std::get;
  using std::in_place;
  using std::in_place_index;
  using std::in_place_index_t;
  using std::in_place_t;
  using std::in_place_type;
  using std::in_place_type_t;
  using std::make_pair;
  using std::piecewise_construct;
  using std::piecewise_construct_t;
#if __cpp_lib_to_underlying
  using std::to_underlying;
#endif
  using std::tuple_element;
  using std::tuple_size;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  namespace rel_ops
  {
    using std::rel_ops::operator!=;
    using std::rel_ops::operator>;
    using std::rel_ops::operator<=;
    using std::rel_ops::operator>=;
  }
#pragma GCC diagnostic pop
#if __cpp_lib_unreachable
  using std::unreachable;
#endif
}

// <valarray>
export namespace std
{
  using std::gslice;
  using std::gslice_array;
  using std::indirect_array;
  using std::mask_array;
  using std::slice;
  using std::slice_array;
  using std::swap;
  using std::valarray;
  using std::operator*;
  using std::operator/;
  using std::operator%;
  using std::operator+;
  using std::operator-;
  using std::operator^;
  using std::operator&;
  using std::operator|;
  using std::operator<<;
  using std::operator>>;
  using std::operator&&;
  using std::operator||;
  using std::operator==;
  using std::operator!=;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::abs;
  using std::acos;
  using std::asin;
  using std::atan;
  using std::atan2;
  using std::begin;
  using std::cos;
  using std::cosh;
  using std::end;
  using std::exp;
  using std::log;
  using std::log10;
  using std::pow;
  using std::sin;
  using std::sinh;
  using std::sqrt;
  using std::tan;
  using std::tanh;
}

// <variant>
export namespace std
{
  using std::get;
  using std::get_if;
  using std::holds_alternative;
  using std::variant;
  using std::variant_alternative;
  using std::variant_alternative_t;
  using std::variant_npos;
  using std::variant_size;
  using std::variant_size_v;
  using std::operator==;
  using std::operator!=;
  using std::operator<;
  using std::operator>;
  using std::operator<=;
  using std::operator>=;
  using std::operator<=>;
  using std::bad_variant_access;
  using std::hash;
  using std::monostate;
  using std::swap;
  using std::visit;
}

// <vector>
export namespace std
{
  using std::vector;
  using std::operator==;
  using std::operator<=>;
  using std::erase;
  using std::erase_if;
  using std::swap;
  namespace pmr
  {
    using std::pmr::vector;
  }
  using std::hash;
}
