Add support for `import std` in Clang 17 or later with libc++

9 files changed, 7033 insertions, 118 deletions

diff --git a/libbuild2/buildfile b/libbuild2/buildfile
index 6d7c597..5ef0006 100644
--- a/libbuild2/buildfile
+++ b/libbuild2/buildfile
@@ -222,6 +222,17 @@ if ($install.root != [null])
       $directory($install.resolve($install.buildfile)), '\\', '\\\\')\"
   #\
 
+  # Data directory or src_root if not installed.
+  #
+  # Note: normalized in both cases.
+  #
+  {obja objs}{utility-installed}: cxx.poptions += \
+    -DBUILD2_INSTALL_DATA=\"$regex.replace(\
+      $install.resolve($install.data), '\\', '\\\\')\"
+
+  {obja objs}{utility-uninstalled}: cxx.poptions += \
+    -DBUILD2_INSTALL_DATA=\"$regex.replace(\
+      $src_root, '\\', '\\\\')\"
 }
 
 if ($cxx.target.class != 'windows')
diff --git a/libbuild2/cc/buildfile b/libbuild2/cc/buildfile
index e090e76..7dcd811 100644
--- a/libbuild2/cc/buildfile
+++ b/libbuild2/cc/buildfile
@@ -18,12 +18,22 @@ intf_libs = ../bin/lib{build2-bin}
 
 ./: lib{build2-cc}: libul{build2-cc}:               \
   {hxx ixx txx cxx}{** -pkgconfig-lib* -**.test...} \
-  h{msvc-setup}                                     \
-  $intf_libs $impl_libs
+  h{msvc-setup}
 
 libul{build2-cc}: cxx{pkgconfig-libpkgconf}: include = $libpkgconf
 libul{build2-cc}: cxx{pkgconfig-libpkg-config}: include = (!$libpkgconf)
 
+libul{build2-cc}: $intf_libs $impl_libs
+
+# libc++ std module interface translation unit.
+#
+# Hopefully temporary, see llvm-project GH issues #73089.
+#
+# @@ TMP: make sure sync'ed with upstream before release (keep this note).
+#
+lib{build2-cc}: file{std.cppm}
+file{std.cppm}@./: install = data/libbuild2/cc/
+
 # Unit tests.
 #
 exe{*.test}:
diff --git a/libbuild2/cc/compile-rule.cxx b/libbuild2/cc/compile-rule.cxx
index 5ac07bc..5d6c029 100644
--- a/libbuild2/cc/compile-rule.cxx
+++ b/libbuild2/cc/compile-rule.cxx
@@ -5626,6 +5626,9 @@ namespace build2
     {
       tracer trace (x, "compile_rule::search_modules");
 
+      context& ctx (bs.ctx);
+      const scope& rs (*bs.root_scope ());
+
       // NOTE: currently we don't see header unit imports (they are handled by
       //       extract_headers() and are not in imports).
 
@@ -5689,10 +5692,10 @@ namespace build2
       // module (or partition) component. Failed that, we will match `format`
       // to `print` because the last character (`t`) is the same.
       //
-      // For std.* modules we only accept non-fuzzy matches (think std.core vs
-      // some core.mxx). And if such a module is unresolved, then we assume it
-      // is pre-built and will be found by some other means (e.g., VC's
-      // IFCPATH).
+      // For std.* modules we only accept non-fuzzy matches (think std.compat
+      // vs some compat.mxx). And if such a module is unresolved, then we
+      // assume it is pre-built and will be found by some other means (e.g.,
+      // VC's IFCPATH).
       //
       // Note also that we handle module partitions the same as submodules. In
       // other words, for matching, `.` and `:` are treated the same.
@@ -5899,6 +5902,7 @@ namespace build2
       // so we actually don't need to pass any extra options (unless things
       // get moved) but they still need access to the BMIs (and things will
       // most likely have to be done differenly for distributed compilation).
+      // @@ Note: no longer the case for Clang either.
       //
       // So the revised plan: on the off chance that some implementation will
       // do it differently we will continue maintaing the imported/re-exported
@@ -6044,7 +6048,15 @@ namespace build2
               continue;
 
             if (const target** p = check_exact (*n))
-              *p = &this->make_module_sidebuild (a, bs, l, *pt, *n); // GCC 4.9
+            {
+              // It seems natural to build a BMI type that corresponds to the
+              // library type. After all, this is where the object file part
+              // of the BMI is going to come from (unless it's a module
+              // interface-only library).
+              //
+              *p = &this->make_module_sidebuild (
+                a, bs, &l, link_type (l).type, *pt, *n).first; // GCC 4.9
+            }
           }
           // Note that in prerequisite targets we will have the libux{}
           // members, not the group.
@@ -6059,112 +6071,194 @@ namespace build2
         }
       };
 
-      for (prerequisite_member p: group_prerequisite_members (a, t))
+      // Pre-resolve std modules in an ad hoc way for certain compilers.
+      //
+      // @@ TODO: cache x_stdlib value.
+      //
+      if (ctype == compiler_type::clang &&
+          cmaj >= 17                    &&
+          cast<string> (rs[x_stdlib]) == "libc++")
       {
-        if (include (a, t, p) != include_type::normal) // Excluded/ad hoc.
-          continue;
-
-        const target* pt (p.load ()); // Should be cached for libraries.
+        // Similar logic to check_exact() above.
+        //
+        done = true;
 
-        if (pt != nullptr)
+        for (size_t i (0); i != n; ++i)
         {
-          const file* lt (nullptr);
-
-          if (const libx* l = pt->is_a<libx> ())
-            lt = link_member (*l, a, li);
-          else if (pt->is_a<liba> () || pt->is_a<libs> () || pt->is_a<libux> ())
-            lt = &pt->as<file> ();
+          module_import& m (imports[i]);
 
-          // If this is a library, check its bmi{}s and mxx{}s.
-          //
-          if (lt != nullptr)
+          if (m.name == "std")
           {
-            find (*lt, find);
+            // Find or insert std.cppm (similar code to pkgconfig.cxx).
+            //
+            // Note: build_install_data is absolute and normalized.
+            //
+            const target& mt (
+              ctx.targets.insert_locked (
+                *x_mod,
+                (dir_path (build_install_data) /= "libbuild2") /= "cc",
+                dir_path (),
+                "std",
+                "cppm",
+                target_decl::implied,
+                trace).first);
 
-            if (done)
-              break;
+            // Which output type should we use, static or shared? The correct
+            // way would be to detect whether static or shared version of
+            // libc++ is to be linked and use the corresponding type. And we
+            // could do that by searching for -static-libstdc++ in loption
+            // (and no, it's not -static-libc++).
+            //
+            // But, looking at the object file produced from std.cppm, it only
+            // contains one symbol, the static object initializer. And this is
+            // unlikely to change since all other non-inline/template symbols
+            // should be in libc++. So feels like it's not worth the trouble
+            // and one variant should be good enough for both cases. Let's use
+            // the shared one for less surprising diagnostics (as in, "why are
+            // you linking obje{} to a shared library?")
+            //
+            // (Of course, theoretically, std.cppm could detect via a macro
+            // whether it's being compiled with -fPIC or not and do things
+            // differently, but this seems far-fetched).
+            //
+            pair<target&, ulock> tl (
+              this->make_module_sidebuild (
+                a, bs, nullptr, otype::s, mt, m.name)); // GCC 4.9
 
-            continue;
-          }
+            if (tl.second.owns_lock ())
+            {
+              value& v (tl.first.append_locked (x_coptions));
 
-          // Fall through.
-        }
+              if (v.null)
+                v = strings {};
 
-        // While it would have been even better not to search for a target, we
-        // need to get hold of the corresponding mxx{} (unlikely but possible
-        // for bmi{} to have a different name).
-        //
-        // While we want to use group_prerequisite_members() below, we cannot
-        // call resolve_group() since we will be doing it "speculatively" for
-        // modules that we may use but also for modules that may use us. This
-        // quickly leads to deadlocks. So instead we are going to perform an
-        // ad hoc group resolution.
-        //
-        const target* pg;
-        if (p.is_a<bmi> ())
-        {
-          pg = pt != nullptr ? pt : &p.search (t);
-          pt = &search (t, btt, p.key ()); // Same logic as in picking obj*{}.
-        }
-        else if (p.is_a (btt))
-        {
-          pg = &search (t, bmi::static_type, p.key ());
-          if (pt == nullptr) pt = &p.search (t);
+              v.as<strings> ().push_back ("-Wno-reserved-module-identifier");
+
+              tl.second.unlock ();
+            }
+
+            pts[start + i].target = &tl.first;
+            m.score = match_max (m.name) + 1;
+            continue; // Scan the rest to detect if all done.
+          }
+
+          done = false;
         }
-        else
-          continue;
+      }
 
-        // Find the mxx{} prerequisite and extract its "file name" for the
-        // fuzzy match unless the user specified the module name explicitly.
-        //
-        for (prerequisite_member p:
-               prerequisite_members (a, t, group_prerequisites (*pt, pg)))
+      // Go over prerequisites and try to resolve imported modules with them.
+      //
+      if (!done)
+      {
+        for (prerequisite_member p: group_prerequisite_members (a, t))
         {
           if (include (a, t, p) != include_type::normal) // Excluded/ad hoc.
             continue;
 
-          if (p.is_a (*x_mod))
+          const target* pt (p.load ()); // Should be cached for libraries.
+
+          if (pt != nullptr)
           {
-            // Check for an explicit module name. Only look for an existing
-            // target (which means the name can only be specified on the
-            // target itself, not target type/pattern-spec).
+            const file* lt (nullptr);
+
+            if (const libx* l = pt->is_a<libx> ())
+              lt = link_member (*l, a, li);
+            else if (pt->is_a<liba> () ||
+                     pt->is_a<libs> () ||
+                     pt->is_a<libux> ())
+              lt = &pt->as<file> ();
+
+            // If this is a library, check its bmi{}s and mxx{}s.
             //
-            const target* t (p.search_existing ());
-            const string* n (t != nullptr
-                             ? cast_null<string> (t->vars[c_module_name])
-                             : nullptr);
-            if (n != nullptr)
+            if (lt != nullptr)
             {
-              if (const target** p = check_exact (*n))
-                *p = pt;
+              find (*lt, find);
+
+              if (done)
+                break;
+
+              continue;
             }
-            else
+
+            // Fall through.
+          }
+
+          // While it would have been even better not to search for a target,
+          // we need to get hold of the corresponding mxx{} (unlikely but
+          // possible for bmi{} to have a different name).
+          //
+          // While we want to use group_prerequisite_members() below, we
+          // cannot call resolve_group() since we will be doing it
+          // "speculatively" for modules that we may use but also for modules
+          // that may use us. This quickly leads to deadlocks. So instead we
+          // are going to perform an ad hoc group resolution.
+          //
+          const target* pg;
+          if (p.is_a<bmi> ())
+          {
+            pg = pt != nullptr ? pt : &p.search (t);
+            pt = &search (t, btt, p.key ()); // Same logic as in picking obj*{}.
+          }
+          else if (p.is_a (btt))
+          {
+            pg = &search (t, bmi::static_type, p.key ());
+            if (pt == nullptr) pt = &p.search (t);
+          }
+          else
+            continue;
+
+          // Find the mxx{} prerequisite and extract its "file name" for the
+          // fuzzy match unless the user specified the module name explicitly.
+          //
+          for (prerequisite_member p:
+                 prerequisite_members (a, t, group_prerequisites (*pt, pg)))
+          {
+            if (include (a, t, p) != include_type::normal) // Excluded/ad hoc.
+              continue;
+
+            if (p.is_a (*x_mod))
             {
-              // Fuzzy match.
+              // Check for an explicit module name. Only look for an existing
+              // target (which means the name can only be specified on the
+              // target itself, not target type/pattern-spec).
               //
-              string f;
+              const target* t (p.search_existing ());
+              const string* n (t != nullptr
+                               ? cast_null<string> (t->vars[c_module_name])
+                               : nullptr);
+              if (n != nullptr)
+              {
+                if (const target** p = check_exact (*n))
+                  *p = pt;
+              }
+              else
+              {
+                // Fuzzy match.
+                //
+                string f;
 
-              // Add the directory part if it is relative. The idea is to
-              // include it into the module match, say hello.core vs
-              // hello/mxx{core}.
-              //
-              // @@ MOD: Why not for absolute? Good question. What if it
-              // contains special components, say, ../mxx{core}?
-              //
-              const dir_path& d (p.dir ());
+                // Add the directory part if it is relative. The idea is to
+                // include it into the module match, say hello.core vs
+                // hello/mxx{core}.
+                //
+                // @@ MOD: Why not for absolute? Good question. What if it
+                // contains special components, say, ../mxx{core}?
+                //
+                const dir_path& d (p.dir ());
 
-              if (!d.empty () && d.relative ())
-                f = d.representation (); // Includes trailing slash.
+                if (!d.empty () && d.relative ())
+                  f = d.representation (); // Includes trailing slash.
 
-              f += p.name ();
-              check_fuzzy (pt, f);
+                f += p.name ();
+                check_fuzzy (pt, f);
+              }
+              break;
             }
-            break;
           }
-        }
 
-        if (done)
-          break;
+          if (done)
+            break;
+        }
       }
 
       // Diagnose unresolved modules.
@@ -6421,13 +6515,18 @@ namespace build2
       return pair<dir_path, const scope&> (move (pd), *as);
     }
 
-    // Synthesize a dependency for building a module binary interface on
-    // the side.
+    // Synthesize a dependency for building a module binary interface of a
+    // library on the side. If library is missing, then assume it's some
+    // ad hoc/system library case (in which case we assume it's binless,
+    // for now).
     //
-    const file& compile_rule::
+    // The return value semantics is as in target_set::insert_locked().
+    //
+    pair<target&, ulock> compile_rule::
     make_module_sidebuild (action a,
                            const scope& bs,
-                           const file& lt,
+                           const file* lt,
+                           otype ot,
                            const target& mt,
                            const string& mn) const
     {
@@ -6448,24 +6547,20 @@ namespace build2
                  back_inserter (mf),
                  [] (char c) {return c == '.' ? '-' : c == ':' ? '+' : c;});
 
-      // It seems natural to build a BMI type that corresponds to the library
-      // type. After all, this is where the object file part of the BMI is
-      // going to come from (unless it's a module interface-only library).
-      //
-      const target_type& tt (compile_types (link_type (lt).type).bmi);
+      const target_type& tt (compile_types (ot).bmi);
 
       // Store the BMI target in the subproject root. If the target already
       // exists then we assume all this is already done (otherwise why would
       // someone have created such a target).
       //
-      if (const file* bt = bs.ctx.targets.find<file> (
+      if (const target* bt = bs.ctx.targets.find (
             tt,
             pd,
             dir_path (), // Always in the out tree.
             mf,
             nullopt,     // Use default extension.
             trace))
-        return *bt;
+        return pair<target&, ulock> (const_cast<target&> (*bt), ulock ());
 
       prerequisites ps;
       ps.push_back (prerequisite (mt));
@@ -6478,19 +6573,22 @@ namespace build2
       //
       // Note: lt is matched and so the group is resolved.
       //
-      ps.push_back (prerequisite (lt));
-      for (prerequisite_member p: group_prerequisite_members (a, lt))
+      if (lt != nullptr)
       {
-        // Ignore update=match.
-        //
-        lookup l;
-        if (include (a, lt, p, &l) != include_type::normal) // Excluded/ad hoc.
-          continue;
-
-        if (p.is_a<libx> () ||
-            p.is_a<liba> () || p.is_a<libs> () || p.is_a<libux> ())
+        ps.push_back (prerequisite (*lt));
+        for (prerequisite_member p: group_prerequisite_members (a, *lt))
         {
-          ps.push_back (p.as_prerequisite ());
+          // Ignore update=match.
+          //
+          lookup l;
+          if (include (a, *lt, p, &l) != include_type::normal) // Excluded/ad hoc.
+            continue;
+
+          if (p.is_a<libx> () ||
+              p.is_a<liba> () || p.is_a<libs> () || p.is_a<libux> ())
+          {
+            ps.push_back (p.as_prerequisite ());
+          }
         }
       }
 
@@ -6503,22 +6601,22 @@ namespace build2
                 target_decl::implied,
                 trace,
                 true /* skip_find */));
-      file& bt (p.first.as<file> ());
 
       // Note that this is racy and someone might have created this target
       // while we were preparing the prerequisite list.
       //
       if (p.second)
       {
-        bt.prerequisites (move (ps));
+        p.first.prerequisites (move (ps));
 
         // Unless this is a binless library, we don't need the object file
         // (see config_data::b_binless for details).
         //
-        bt.vars.assign (b_binless) = (lt.mtime () == timestamp_unreal);
+        p.first.vars.assign (b_binless) = (lt == nullptr ||
+                                           lt->mtime () == timestamp_unreal);
       }
 
-      return bt;
+      return p;
     }
 
     // Synthesize a dependency for building a header unit binary interface on
diff --git a/libbuild2/cc/compile-rule.hxx b/libbuild2/cc/compile-rule.hxx
index a9a22c4..0886b4b 100644
--- a/libbuild2/cc/compile-rule.hxx
+++ b/libbuild2/cc/compile-rule.hxx
@@ -156,8 +156,9 @@ namespace build2
       pair<dir_path, const scope&>
       find_modules_sidebuild (const scope&) const;
 
-      const file&
-      make_module_sidebuild (action, const scope&, const file&,
+      pair<target&, ulock>
+      make_module_sidebuild (action, const scope&,
+                             const file*, otype,
                              const target&, const string&) const;
 
       const file&
diff --git a/libbuild2/cc/pkgconfig.cxx b/libbuild2/cc/pkgconfig.cxx
index b0518f9..7c9f9b1 100644
--- a/libbuild2/cc/pkgconfig.cxx
+++ b/libbuild2/cc/pkgconfig.cxx
@@ -1036,7 +1036,7 @@ namespace build2
               target_decl::implied,
               trace));
 
-          target& mt (tl.first);
+          file& mt (tl.first.as<file> ());
 
           // If the target already exists, then setting its variables is not
           // MT-safe. So currently we only do it if we have the lock (and thus
@@ -1054,6 +1054,7 @@ namespace build2
           //
           if (tl.second.owns_lock ())
           {
+            mt.path (move (mp));
             mt.vars.assign (c_module_name) = move (mn);
 
             // Set module properties. Note that if unspecified we should still
@@ -1124,7 +1125,7 @@ namespace build2
               target_decl::implied,
               trace));
 
-          target& ht (tl.first);
+          file& ht (tl.first.as<file> ());
 
           // If the target already exists, then setting its variables is not
           // MT-safe. So currently we only do it if we have the lock (and thus
@@ -1133,6 +1134,7 @@ namespace build2
           //
           if (tl.second.owns_lock ())
           {
+            ht.path (move (hp));
             ht.vars.assign (c_importable) = true;
             tl.second.unlock ();
           }
diff --git a/libbuild2/cc/std.cppm b/libbuild2/cc/std.cppm
new file mode 100644
index 0000000..5368d1c
--- /dev/null
+++ b/libbuild2/cc/std.cppm
@@ -0,0 +1,6781 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// WARNING, this entire header is generated by
+// utils/generate_std_cppm_in.py
+// DO NOT MODIFY!
+
+module;
+
+#include <__config>
+
+#if _LIBCPP_VERSION < 170000
+#error libc++ version 17.0.0 or later required
+#endif
+
+// The headers of Table 24: C++ library headers [tab:headers.cpp]
+// and the headers of Table 25: C++ headers for C library facilities [tab:headers.cpp.c]
+#include <algorithm>
+#include <any>
+#include <array>
+#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
+#  include <atomic>
+#endif
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <barrier>
+#endif
+#include <bit>
+#include <bitset>
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cfenv>
+#include <cfloat>
+#include <charconv>
+#include <chrono>
+#include <cinttypes>
+#include <climits>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <clocale>
+#endif
+#include <cmath>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <codecvt>
+#endif
+#include <compare>
+#include <complex>
+#include <concepts>
+#include <condition_variable>
+#include <coroutine>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <cuchar>
+#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#  include <cwchar>
+#endif
+#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#  include <cwctype>
+#endif
+#include <deque>
+#include <exception>
+#include <execution>
+#include <expected>
+#include <filesystem>
+#include <format>
+#include <forward_list>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <fstream>
+#endif
+#include <functional>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <future>
+#endif
+#include <initializer_list>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <iomanip>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <ios>
+#endif
+#include <iosfwd>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <iostream>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <istream>
+#endif
+#include <iterator>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <latch>
+#endif
+#include <limits>
+#include <list>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <locale>
+#endif
+#include <map>
+#include <mdspan>
+#include <memory>
+#include <memory_resource>
+#include <mutex>
+#include <new>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <ostream>
+#endif
+#include <print>
+#include <queue>
+#include <random>
+#include <ranges>
+#include <ratio>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <regex>
+#endif
+#include <scoped_allocator>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <semaphore>
+#endif
+#include <set>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <shared_mutex>
+#endif
+#include <source_location>
+#include <span>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <sstream>
+#endif
+#include <stack>
+#include <stdexcept>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <stop_token>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <streambuf>
+#endif
+#include <string>
+#include <string_view>
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  include <strstream>
+#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if __has_include(<syncstream>)
+#  define _LIPCPP_HAS_YES_SYNCSTREAM
+#  include <syncstream>
+#endif
+#endif
+#include <system_error>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <thread>
+#endif
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <valarray>
+#include <variant>
+#include <vector>
+#include <version>
+
+#if 0
+// *** Headers not yet available ***
+#if __has_include(<debugging>)
+#  error "update the header information for <debugging> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<debugging>)
+#if __has_include(<flat_map>)
+#  error "update the header information for <flat_map> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<flat_map>)
+#if __has_include(<flat_set>)
+#  error "update the header information for <flat_set> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<flat_set>)
+#if __has_include(<generator>)
+#  error "update the header information for <generator> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<generator>)
+#if __has_include(<hazard_pointer>)
+#  error "update the header information for <hazard_pointer> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<hazard_pointer>)
+#if __has_include(<linalg>)
+#  error "update the header information for <linalg> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<linalg>)
+#if __has_include(<rcu>)
+#  error "update the header information for <rcu> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<rcu>)
+#if __has_include(<spanstream>)
+#  error "update the header information for <spanstream> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<spanstream>)
+#if __has_include(<stacktrace>)
+#  error "update the header information for <stacktrace> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<stacktrace>)
+#if __has_include(<stdfloat>)
+#  error "update the header information for <stdfloat> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<stdfloat>)
+#if __has_include(<text_encoding>)
+#  error "update the header information for <text_encoding> in libcxx/utils/generate_std_cppm_in.py"
+#endif //   __has_include(<text_encoding>)
+#endif
+
+export module std;
+
+// algorithm.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  namespace ranges {
+    // [algorithms.results], algorithm result types
+    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::in_value_result;
+    using std::ranges::min_max_result;
+    // using std::ranges::out_value_result;
+  } // namespace ranges
+
+  // [alg.nonmodifying], non-modifying sequence operations
+  // [alg.all.of], all of
+  using std::all_of;
+  namespace ranges {
+    using std::ranges::all_of;
+  }
+
+  // [alg.any.of], any of
+  using std::any_of;
+  namespace ranges {
+    using std::ranges::any_of;
+  }
+
+  // [alg.none.of], none of
+  using std::none_of;
+  namespace ranges {
+    using std::ranges::none_of;
+  }
+
+  // [alg.contains], contains
+#if 0
+  namespace ranges {
+    using std::ranges::contains;
+    using std::ranges::contains_subrange;
+  } // namespace ranges
+#endif
+
+  // [alg.foreach], for each
+  using std::for_each;
+
+  namespace ranges {
+    using std::ranges::for_each;
+    using std::ranges::for_each_result;
+  } // namespace ranges
+
+  using std::for_each_n;
+
+  namespace ranges {
+    using std::ranges::for_each_n_result;
+
+    using std::ranges::for_each_n;
+  } // namespace ranges
+
+  // [alg.find], find
+  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;
+  } // namespace ranges
+
+  namespace ranges {
+#if 0
+    using std::ranges::find_last;
+    using std::ranges::find_last_if;
+    using std::ranges::find_last_if_not;
+#endif
+  } // namespace ranges
+
+  // [alg.find.end], find end
+  using std::find_end;
+
+  namespace ranges {
+    using std::ranges::find_end;
+  }
+
+  // [alg.find.first.of], find first
+  using std::find_first_of;
+
+  namespace ranges {
+    using std::ranges::find_first_of;
+  }
+
+  // [alg.adjacent.find], adjacent find
+  using std::adjacent_find;
+
+  namespace ranges {
+    using std::ranges::adjacent_find;
+  }
+
+  // [alg.count], count
+  using std::count;
+  using std::count_if;
+
+  namespace ranges {
+    using std::ranges::count;
+    using std::ranges::count_if;
+  } // namespace ranges
+
+  // [mismatch], mismatch
+  using std::mismatch;
+
+  namespace ranges {
+    using std::ranges::mismatch_result;
+
+    using std::ranges::mismatch;
+  } // namespace ranges
+
+  // [alg.equal], equal
+  using std::equal;
+
+  namespace ranges {
+    using std::ranges::equal;
+  }
+
+  // [alg.is.permutation], is permutation
+  using std::is_permutation;
+
+  namespace ranges {
+    using std::ranges::is_permutation;
+  }
+
+  // [alg.search], search
+  using std::search;
+
+  namespace ranges {
+    using std::ranges::search;
+  }
+
+  using std::search_n;
+
+  namespace ranges {
+    using std::ranges::search_n;
+  }
+
+  namespace ranges {
+#if _LIBCPP_STD_VER >= 23
+    // [alg.starts.with], starts with
+    using std::ranges::starts_with;
+
+#if _LIBCPP_VERSION >= 180000
+    // [alg.ends.with], ends with
+    using std::ranges::ends_with;
+#endif
+
+#  if 0
+    // [alg.fold], fold
+    using std::ranges::fold_left;
+    using std::ranges::fold_left_first;
+    using std::ranges::fold_right;
+    using std::ranges::fold_right_last;
+    using std::ranges::fold_left_with_iter;
+    using std::ranges::fold_left_with_iter_result;
+    using std::ranges::fold_left_with_iter;
+    using std::ranges::fold_left_first_with_iter;
+    using std::ranges::fold_left_first_with_iter;
+#  endif
+#endif // _LIBCPP_STD_VER >= 23
+  }    // namespace ranges
+
+  // [alg.modifying.operations], mutating sequence operations
+  // [alg.copy], copy
+  using std::copy;
+
+  namespace ranges {
+    using std::ranges::copy;
+    using std::ranges::copy_result;
+  } // namespace ranges
+
+  using std::copy_n;
+
+  namespace ranges {
+    using std::ranges::copy_n;
+    using std::ranges::copy_n_result;
+  } // namespace ranges
+
+  using std::copy_if;
+
+  namespace ranges {
+    using std::ranges::copy_if;
+    using std::ranges::copy_if_result;
+  } // namespace ranges
+
+  using std::copy_backward;
+
+  namespace ranges {
+    using std::ranges::copy_backward;
+    using std::ranges::copy_backward_result;
+  } // namespace ranges
+
+  // [alg.move], move
+  using std::move;
+
+  namespace ranges {
+    using std::ranges::move;
+    using std::ranges::move_result;
+  } // namespace ranges
+
+  using std::move_backward;
+
+  namespace ranges {
+    using std::ranges::move_backward;
+    using std::ranges::move_backward_result;
+  } // namespace ranges
+
+  // [alg.swap], swap
+  using std::swap_ranges;
+
+  namespace ranges {
+    using std::ranges::swap_ranges;
+    using std::ranges::swap_ranges_result;
+  } // namespace ranges
+
+  using std::iter_swap;
+
+  // [alg.transform], transform
+  using std::transform;
+
+  namespace ranges {
+    using std::ranges::binary_transform_result;
+    using std::ranges::unary_transform_result;
+
+    using std::ranges::transform;
+
+  } // namespace ranges
+
+  using std::replace;
+  using std::replace_if;
+
+  namespace ranges {
+    using std::ranges::replace;
+    using std::ranges::replace_if;
+  } // namespace ranges
+
+  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;
+  } // namespace ranges
+
+  // [alg.fill], fill
+  using std::fill;
+  using std::fill_n;
+
+  namespace ranges {
+    using std::ranges::fill;
+    using std::ranges::fill_n;
+  } // namespace ranges
+
+  // [alg.generate], generate
+  using std::generate;
+  using std::generate_n;
+
+  namespace ranges {
+    using std::ranges::generate;
+    using std::ranges::generate_n;
+  } // namespace ranges
+
+  // [alg.remove], remove
+  using std::remove;
+  using std::remove_if;
+
+  namespace ranges {
+    using std::ranges::remove;
+    using std::ranges::remove_if;
+  } // namespace ranges
+
+  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;
+  } // namespace ranges
+
+  // [alg.unique], unique
+  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;
+  } // namespace ranges
+
+  // [alg.reverse], reverse
+  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;
+  } // namespace ranges
+
+  // [alg.rotate], rotate
+  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;
+  } // namespace ranges
+
+  // [alg.random.sample], sample
+  using std::sample;
+
+  namespace ranges {
+    using std::ranges::sample;
+  }
+
+  // [alg.random.shuffle], shuffle
+  using std::shuffle;
+
+  namespace ranges {
+    using std::ranges::shuffle;
+  }
+
+  // [alg.shift], shift
+  using std::shift_left;
+
+  namespace ranges {
+    // using std::ranges::shift_left;
+  }
+
+  using std::shift_right;
+
+  namespace ranges {
+    // using std::ranges::shift_right;
+  }
+
+  // [alg.sorting], sorting and related operations
+  // [alg.sort], sorting
+  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;
+  } // namespace ranges
+
+  using std::is_sorted;
+  using std::is_sorted_until;
+
+  namespace ranges {
+    using std::ranges::is_sorted;
+    using std::ranges::is_sorted_until;
+  } // namespace ranges
+
+  // [alg.nth.element], Nth element
+  using std::nth_element;
+
+  namespace ranges {
+    using std::ranges::nth_element;
+  }
+
+  // [alg.binary.search], binary search
+  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;
+  }
+
+  // [alg.partitions], partitions
+  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;
+  } // namespace ranges
+
+  using std::partition_point;
+
+  namespace ranges {
+    using std::ranges::partition_point;
+  }
+  // [alg.merge], merge
+  using std::merge;
+  namespace ranges {
+    using std::ranges::merge;
+    using std::ranges::merge_result;
+  } // namespace ranges
+
+  using std::inplace_merge;
+
+  namespace ranges {
+    using std::ranges::inplace_merge;
+  }
+
+  // [alg.set.operations], set operations
+  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;
+  } // namespace ranges
+
+  using std::set_intersection;
+  namespace ranges {
+    using std::ranges::set_intersection;
+    using std::ranges::set_intersection_result;
+  } // namespace ranges
+
+  using std::set_difference;
+
+  namespace ranges {
+    using std::ranges::set_difference;
+    using std::ranges::set_difference_result;
+  } // namespace ranges
+
+  using std::set_symmetric_difference;
+
+  namespace ranges {
+    using std::ranges::set_symmetric_difference_result;
+
+    using std::ranges::set_symmetric_difference;
+  } // namespace ranges
+
+  // [alg.heap.operations], heap operations
+  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;
+  }
+
+  // [alg.min.max], minimum and maximum
+  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_result;
+
+    using std::ranges::minmax;
+  } // namespace ranges
+
+  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_result;
+
+    using std::ranges::minmax_element;
+  } // namespace ranges
+    // [alg.clamp], bounded value
+  using std::clamp;
+
+  namespace ranges {
+    using std::ranges::clamp;
+  }
+
+  // [alg.lex.comparison], lexicographical comparison
+  using std::lexicographical_compare;
+
+  namespace ranges {
+    using std::ranges::lexicographical_compare;
+  }
+
+  // [alg.three.way], three-way comparison algorithms
+  using std::lexicographical_compare_three_way;
+
+  // [alg.permutation.generators], permutations
+  using std::next_permutation;
+
+  namespace ranges {
+    using std::ranges::next_permutation_result;
+
+    using std::ranges::next_permutation;
+  } // namespace ranges
+
+  using std::prev_permutation;
+
+  namespace ranges {
+    using std::ranges::prev_permutation_result;
+
+    using std::ranges::prev_permutation;
+  } // namespace ranges
+
+} // namespace std
+
+// any.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [any.bad.any.cast], class bad_any_cast
+  using std::bad_any_cast;
+
+  // [any.class], class any
+  using std::any;
+
+  // [any.nonmembers], non-member functions
+  using std::any_cast;
+  using std::make_any;
+  using std::swap;
+
+} // namespace std
+
+// array.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [array], class template array
+  using std::array;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  // [array.special], specialized algorithms
+  using std::swap;
+
+  // [array.creation], array creation functions
+  using std::to_array;
+
+  // [array.tuple], tuple interface
+  using std::get;
+  using std::tuple_element;
+  using std::tuple_size;
+
+} // namespace std
+
+// atomic.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [atomics.order], order and consistency
+  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;
+
+  using std::kill_dependency;
+
+  // [atomics.ref.generic], class template atomic_ref
+  // [atomics.ref.pointer], partial specialization for pointers
+  // using std::atomic_ref;
+
+  // [atomics.types.generic], class template atomic
+  using std::atomic;
+
+  // [atomics.nonmembers], non-member functions
+  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::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_notify_all;
+  using std::atomic_notify_one;
+  using std::atomic_wait;
+  using std::atomic_wait_explicit;
+
+  // [atomics.alias], type aliases
+  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_int;
+  using std::atomic_llong;
+  using std::atomic_long;
+  using std::atomic_schar;
+  using std::atomic_short;
+  using std::atomic_uchar;
+  using std::atomic_uint;
+  using std::atomic_ullong;
+  using std::atomic_ulong;
+  using std::atomic_ushort;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::atomic_wchar_t;
+#endif
+
+  using std::atomic_int16_t;
+  using std::atomic_int32_t;
+  using std::atomic_int64_t;
+  using std::atomic_int8_t;
+  using std::atomic_uint16_t;
+  using std::atomic_uint32_t;
+  using std::atomic_uint64_t;
+  using std::atomic_uint8_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_uint_least16_t;
+  using std::atomic_uint_least32_t;
+  using std::atomic_uint_least64_t;
+  using std::atomic_uint_least8_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_uint_fast16_t;
+  using std::atomic_uint_fast32_t;
+  using std::atomic_uint_fast64_t;
+  using std::atomic_uint_fast8_t;
+
+  using std::atomic_intmax_t;
+  using std::atomic_intptr_t;
+  using std::atomic_ptrdiff_t;
+  using std::atomic_size_t;
+  using std::atomic_uintmax_t;
+  using std::atomic_uintptr_t;
+
+  using std::atomic_signed_lock_free;
+  using std::atomic_unsigned_lock_free;
+
+  // [atomics.flag], flag type and operations
+  using std::atomic_flag;
+
+  using std::atomic_flag_clear;
+  using std::atomic_flag_clear_explicit;
+  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_notify_all;
+  using std::atomic_flag_notify_one;
+  using std::atomic_flag_wait;
+  using std::atomic_flag_wait_explicit;
+
+  // [atomics.fences], fences
+  using std::atomic_signal_fence;
+  using std::atomic_thread_fence;
+
+  // [depr.atomics.nonmembers]
+  using std::atomic_init;
+
+} // namespace std
+
+// barrier.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  using std::barrier;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// bit.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [bit.cast], bit_cast
+  using std::bit_cast;
+
+#if _LIBCPP_STD_VER >= 23
+  // [bit.byteswap], byteswap
+  using std::byteswap;
+#endif
+
+  // [bit.pow.two], integral powers of 2
+  using std::bit_ceil;
+  using std::bit_floor;
+  using std::bit_width;
+  using std::has_single_bit;
+
+  // [bit.rotate], rotating
+  using std::rotl;
+  using std::rotr;
+
+  // [bit.count], counting
+  using std::countl_one;
+  using std::countl_zero;
+  using std::countr_one;
+  using std::countr_zero;
+  using std::popcount;
+
+  // [bit.endian], endian
+  using std::endian;
+} // namespace std
+
+// bitset.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::bitset;
+
+  // [bitset.operators], bitset operators
+  using std::operator&;
+  using std::operator|;
+  using std::operator^;
+  using std::operator>>;
+  using std::operator<<;
+
+  // [bitset.hash], hash support
+  using std::hash;
+
+} // namespace std
+
+// cassert.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std
+
+// cctype.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  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::tolower;
+  using std::toupper;
+} // namespace std
+
+// cerrno.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std
+
+// cfenv.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // types
+  using std::fenv_t;
+  using std::fexcept_t;
+
+  // functions
+  using std::feclearexcept;
+  using std::fegetexceptflag;
+  using std::feraiseexcept;
+  using std::fesetexceptflag;
+  using std::fetestexcept;
+
+  using std::fegetround;
+  using std::fesetround;
+
+  using std::fegetenv;
+  using std::feholdexcept;
+  using std::fesetenv;
+  using std::feupdateenv;
+
+} // namespace std
+
+// cfloat.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std
+
+// charconv.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // floating-point format for primitive numerical conversion
+  using std::chars_format;
+
+  // chars_format is a bitmask type.
+  // [bitmask.types] specified operators
+  using std::operator&;
+  using std::operator&=;
+  using std::operator^;
+  using std::operator^=;
+  using std::operator|;
+  using std::operator|=;
+  using std::operator~;
+
+  // [charconv.to.chars], primitive numerical output conversion
+  using std::to_chars_result;
+
+  using std::to_chars;
+
+  // [charconv.from.chars], primitive numerical input conversion
+  using std::from_chars_result;
+
+  using std::from_chars;
+} // namespace std
+
+// chrono.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  namespace chrono {
+    using std::chrono::duration;
+    using std::chrono::time_point;
+
+  } // namespace chrono
+
+  using std::common_type;
+
+  namespace chrono {
+
+    // [time.traits], customization traits
+    using std::chrono::treat_as_floating_point;
+    using std::chrono::treat_as_floating_point_v;
+
+    using std::chrono::duration_values;
+
+    // using std::chrono::is_clock;
+    // using std::chrono::is_clock_v;
+
+    // [time.duration.nonmember], duration arithmetic
+    using std::chrono::operator+;
+    using std::chrono::operator-;
+    using std::chrono::operator*;
+    using std::chrono::operator/;
+    using std::chrono::operator%;
+
+    // [time.duration.comparisons], duration comparisons
+    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<=>;
+
+    // [time.duration.cast], conversions
+    using std::chrono::ceil;
+    using std::chrono::duration_cast;
+    using std::chrono::floor;
+    using std::chrono::round;
+
+    // [time.duration.io], duration I/O
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+    using std::chrono::operator<<;
+#endif
+    // using std::chrono::from_stream;
+
+    // convenience typedefs
+    using std::chrono::days;
+    using std::chrono::hours;
+    using std::chrono::microseconds;
+    using std::chrono::milliseconds;
+    using std::chrono::minutes;
+    using std::chrono::months;
+    using std::chrono::nanoseconds;
+    using std::chrono::seconds;
+    using std::chrono::weeks;
+    using std::chrono::years;
+
+    // [time.point.nonmember], time_point arithmetic
+
+    // [time.point.comparisons], time_point comparisons
+
+    // [time.point.cast], conversions
+    using std::chrono::time_point_cast;
+
+    // [time.duration.alg], specialized algorithms
+    using std::chrono::abs;
+
+    // [time.clock.system], class system_clock
+    using std::chrono::system_clock;
+
+    using std::chrono::sys_days;
+    using std::chrono::sys_seconds;
+    using std::chrono::sys_time;
+
+#if 0
+    // [time.clock.utc], class utc_clock
+    using std::chrono::utc_clock;
+
+    using std::chrono::utc_seconds;
+    using std::chrono::utc_time;
+
+    using std::chrono::leap_second_info;
+
+    using std::chrono::get_leap_second_info;
+    // [time.clock.tai], class tai_clock
+    using std::chrono::tai_clock;
+
+    using std::chrono::tai_seconds;
+    using std::chrono::tai_time;
+
+    // [time.clock.gps], class gps_clock
+    using std::chrono::gps_clock;
+
+    using std::chrono::gps_seconds;
+    using std::chrono::gps_time;
+#endif
+    // [time.clock.file], type file_clock
+    using std::chrono::file_clock;
+
+    using std::chrono::file_time;
+
+#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
+    // [time.clock.steady], class steady_clock
+    using std::chrono::steady_clock;
+#endif
+
+    // [time.clock.hires], class high_resolution_clock
+    using std::chrono::high_resolution_clock;
+
+    // [time.clock.local], local time
+    using std::chrono::local_days;
+    using std::chrono::local_seconds;
+    using std::chrono::local_t;
+    using std::chrono::local_time;
+
+    // [time.clock.cast], time_point conversions
+    // using std::chrono::clock_time_conversion;
+
+    // using std::chrono::clock_cast;
+
+    // [time.cal.last], class last_spec
+    using std::chrono::last_spec;
+
+    // [time.cal.day], class day
+    using std::chrono::day;
+
+    // [time.cal.month], class month
+    using std::chrono::month;
+
+    // [time.cal.year], class year
+    using std::chrono::year;
+
+    // [time.cal.wd], class weekday
+    using std::chrono::weekday;
+
+    // [time.cal.wdidx], class weekday_indexed
+    using std::chrono::weekday_indexed;
+
+    // [time.cal.wdlast], class weekday_last
+    using std::chrono::weekday_last;
+
+    // [time.cal.md], class month_day
+    using std::chrono::month_day;
+
+    // [time.cal.mdlast], class month_day_last
+    using std::chrono::month_day_last;
+
+    // [time.cal.mwd], class month_weekday
+    using std::chrono::month_weekday;
+
+    // [time.cal.mwdlast], class month_weekday_last
+    using std::chrono::month_weekday_last;
+
+    // [time.cal.ym], class year_month
+    using std::chrono::year_month;
+
+    // [time.cal.ymd], class year_month_day
+    using std::chrono::year_month_day;
+
+    // [time.cal.ymdlast], class year_month_day_last
+    using std::chrono::year_month_day_last;
+
+    // [time.cal.ymwd], class year_month_weekday
+    using std::chrono::year_month_weekday;
+
+    // [time.cal.ymwdlast], class year_month_weekday_last
+    using std::chrono::year_month_weekday_last;
+
+    // [time.cal.operators], civil calendar conventional syntax operators
+
+    // [time.hms], class template hh_mm_ss
+    using std::chrono::hh_mm_ss;
+
+    // [time.12], 12/24 hour functions
+    using std::chrono::is_am;
+    using std::chrono::is_pm;
+    using std::chrono::make12;
+    using std::chrono::make24;
+
+#if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                              \
+    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+#  ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+    // [time.zone.db], time zone database
+    using std::chrono::tzdb;
+    using std::chrono::tzdb_list;
+
+    // [time.zone.db.access], time zone database access
+    // using std::chrono::current_zone;
+    using std::chrono::get_tzdb;
+    using std::chrono::get_tzdb_list;
+    // using std::chrono::locate_zone;
+
+    // [time.zone.db.remote], remote time zone database support
+    using std::chrono::reload_tzdb;
+    using std::chrono::remote_version;
+
+#  endif //  !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&
+         //    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+#  if 0
+    // [time.zone.exception], exception classes
+    using std::chrono::ambiguous_local_time;
+    using std::chrono::nonexistent_local_time;
+
+    // [time.zone.info], information classes
+    using std::chrono::sys_info;
+
+    // [time.zone.timezone], class time_zone
+    using std::chrono::choose;
+    using std::chrono::time_zone;
+
+    // [time.zone.zonedtraits], class template zoned_traits
+    using std::chrono::zoned_traits;
+
+    // [time.zone.zonedtime], class template zoned_time
+    using std::chrono::zoned_time;
+
+    using std::chrono::zoned_seconds;
+
+    // [time.zone.leap], leap second support
+    using std::chrono::leap_second;
+
+    // [time.zone.link], class time_zone_link
+    using std::chrono::time_zone_link;
+
+    // [time.format], formatting
+    using std::chrono::local_time_format;
+#  endif
+#endif // _LIBCPP_ENABLE_EXPERIMENTAL
+  }    // namespace chrono
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::formatter;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+
+  namespace chrono {
+    // using std::chrono::parse;
+
+    // calendrical constants
+    using std::chrono::last;
+
+    using std::chrono::Friday;
+    using std::chrono::Monday;
+    using std::chrono::Saturday;
+    using std::chrono::Sunday;
+    using std::chrono::Thursday;
+    using std::chrono::Tuesday;
+    using std::chrono::Wednesday;
+
+    using std::chrono::April;
+    using std::chrono::August;
+    using std::chrono::December;
+    using std::chrono::February;
+    using std::chrono::January;
+    using std::chrono::July;
+    using std::chrono::June;
+    using std::chrono::March;
+    using std::chrono::May;
+    using std::chrono::November;
+    using std::chrono::October;
+    using std::chrono::September;
+
+  } // namespace chrono
+
+} // namespace std
+export namespace std::inline literals::inline chrono_literals {
+  // [time.duration.literals], suffixes for duration 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::.cal.day.nonmembers], non-member functions
+  using std::literals::chrono_literals::operator""d;
+
+  // [using std::literals::chrono_literals::.cal.year.nonmembers], non-member functions
+  using std::literals::chrono_literals::operator""y;
+} // namespace std::inline literals::inline chrono_literals
+
+// cinttypes.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::imaxdiv_t;
+
+  using std::imaxabs;
+  using std::imaxdiv;
+  using std::strtoimax;
+  using std::strtoumax;
+  using std::wcstoimax;
+  using std::wcstoumax;
+
+  // abs is conditionally here, but always present in cmath.cppm. To avoid
+  // conflicing declarations omit the using here.
+
+  // div is conditionally here, but always present in cstdlib.cppm. To avoid
+  // conflicing declarations omit the using here.
+} // namespace std
+
+// climits.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std
+
+// clocale.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::lconv;
+
+  using std::localeconv;
+  using std::setlocale;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// cmath.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  using std::double_t;
+  using std::float_t;
+
+  using std::acos;
+  using std::acosf;
+  using std::acosl;
+
+  using std::asin;
+  using std::asinf;
+  using std::asinl;
+
+  using std::atan;
+  using std::atanf;
+  using std::atanl;
+
+  using std::atan2;
+  using std::atan2f;
+  using std::atan2l;
+
+  using std::cos;
+  using std::cosf;
+  using std::cosl;
+
+  using std::sin;
+  using std::sinf;
+  using std::sinl;
+
+  using std::tan;
+  using std::tanf;
+  using std::tanl;
+
+  using std::acosh;
+  using std::acoshf;
+  using std::acoshl;
+
+  using std::asinh;
+  using std::asinhf;
+  using std::asinhl;
+
+  using std::atanh;
+  using std::atanhf;
+  using std::atanhl;
+
+  using std::cosh;
+  using std::coshf;
+  using std::coshl;
+
+  using std::sinh;
+  using std::sinhf;
+  using std::sinhl;
+
+  using std::tanh;
+  using std::tanhf;
+  using std::tanhl;
+
+  using std::exp;
+  using std::expf;
+  using std::expl;
+
+  using std::exp2;
+  using std::exp2f;
+  using std::exp2l;
+
+  using std::expm1;
+  using std::expm1f;
+  using std::expm1l;
+
+  using std::frexp;
+  using std::frexpf;
+  using std::frexpl;
+
+  using std::ilogb;
+  using std::ilogbf;
+  using std::ilogbl;
+
+  using std::ldexp;
+  using std::ldexpf;
+  using std::ldexpl;
+
+  using std::log;
+  using std::logf;
+  using std::logl;
+
+  using std::log10;
+  using std::log10f;
+  using std::log10l;
+
+  using std::log1p;
+  using std::log1pf;
+  using std::log1pl;
+
+  using std::log2;
+  using std::log2f;
+  using std::log2l;
+
+  using std::logb;
+  using std::logbf;
+  using std::logbl;
+
+  using std::modf;
+  using std::modff;
+  using std::modfl;
+
+  using std::scalbn;
+  using std::scalbnf;
+  using std::scalbnl;
+
+  using std::scalbln;
+  using std::scalblnf;
+  using std::scalblnl;
+
+  using std::cbrt;
+  using std::cbrtf;
+  using std::cbrtl;
+
+  // [c.math.abs], absolute values
+  using std::abs;
+
+  using std::fabs;
+  using std::fabsf;
+  using std::fabsl;
+
+  using std::hypot;
+  using std::hypotf;
+  using std::hypotl;
+
+  // [c.math.hypot3], three-dimensional hypotenuse
+
+  using std::pow;
+  using std::powf;
+  using std::powl;
+
+  using std::sqrt;
+  using std::sqrtf;
+  using std::sqrtl;
+
+  using std::erf;
+  using std::erff;
+  using std::erfl;
+
+  using std::erfc;
+  using std::erfcf;
+  using std::erfcl;
+
+  using std::lgamma;
+  using std::lgammaf;
+  using std::lgammal;
+
+  using std::tgamma;
+  using std::tgammaf;
+  using std::tgammal;
+
+  using std::ceil;
+  using std::ceilf;
+  using std::ceill;
+
+  using std::floor;
+  using std::floorf;
+  using std::floorl;
+
+  using std::nearbyint;
+  using std::nearbyintf;
+  using std::nearbyintl;
+
+  using std::rint;
+  using std::rintf;
+  using std::rintl;
+
+  using std::lrint;
+  using std::lrintf;
+  using std::lrintl;
+
+  using std::llrint;
+  using std::llrintf;
+  using std::llrintl;
+
+  using std::round;
+  using std::roundf;
+  using std::roundl;
+
+  using std::lround;
+  using std::lroundf;
+  using std::lroundl;
+
+  using std::llround;
+  using std::llroundf;
+  using std::llroundl;
+
+  using std::trunc;
+  using std::truncf;
+  using std::truncl;
+
+  using std::fmod;
+  using std::fmodf;
+  using std::fmodl;
+
+  using std::remainder;
+  using std::remainderf;
+  using std::remainderl;
+
+  using std::remquo;
+  using std::remquof;
+  using std::remquol;
+
+  using std::copysign;
+  using std::copysignf;
+  using std::copysignl;
+
+  using std::nan;
+  using std::nanf;
+  using std::nanl;
+
+  using std::nextafter;
+  using std::nextafterf;
+  using std::nextafterl;
+
+  using std::nexttoward;
+  using std::nexttowardf;
+  using std::nexttowardl;
+
+  using std::fdim;
+  using std::fdimf;
+  using std::fdiml;
+
+  using std::fmax;
+  using std::fmaxf;
+  using std::fmaxl;
+
+  using std::fmin;
+  using std::fminf;
+  using std::fminl;
+
+  using std::fma;
+  using std::fmaf;
+  using std::fmal;
+
+  // [c.math.lerp], linear interpolation
+  using std::lerp;
+
+  // [c.math.fpclass], classification / comparison functions
+  using std::fpclassify;
+  using std::isfinite;
+  using std::isgreater;
+  using std::isgreaterequal;
+  using std::isinf;
+  using std::isless;
+  using std::islessequal;
+  using std::islessgreater;
+  using std::isnan;
+  using std::isnormal;
+  using std::isunordered;
+  using std::signbit;
+
+  // [sf.cmath], mathematical special functions
+#if 0
+  // [sf.cmath.assoc.laguerre], associated Laguerre polynomials
+  using std::assoc_laguerre;
+  using std::assoc_laguerref;
+  using std::assoc_laguerrel;
+
+  // [sf.cmath.assoc.legendre], associated Legendre functions
+  using std::assoc_legendre;
+  using std::assoc_legendref;
+  using std::assoc_legendrel;
+
+  // [sf.cmath.beta], beta function
+  using std::beta;
+  using std::betaf;
+  using std::betal;
+
+  // [sf.cmath.comp.ellint.1], complete elliptic integral of the first kind
+  using std::comp_ellint_1;
+  using std::comp_ellint_1f;
+  using std::comp_ellint_1l;
+
+  // [sf.cmath.comp.ellint.2], complete elliptic integral of the second kind
+  using std::comp_ellint_2;
+  using std::comp_ellint_2f;
+  using std::comp_ellint_2l;
+
+  // [sf.cmath.comp.ellint.3], complete elliptic integral of the third kind
+  using std::comp_ellint_3;
+  using std::comp_ellint_3f;
+  using std::comp_ellint_3l;
+
+  // [sf.cmath.cyl.bessel.i], regular modified cylindrical Bessel functions
+  using std::cyl_bessel_i;
+  using std::cyl_bessel_if;
+  using std::cyl_bessel_il;
+
+  // [sf.cmath.cyl.bessel.j], cylindrical Bessel functions of the first kind
+  using std::cyl_bessel_j;
+  using std::cyl_bessel_jf;
+  using std::cyl_bessel_jl;
+
+  // [sf.cmath.cyl.bessel.k], irregular modified cylindrical Bessel functions
+  using std::cyl_bessel_k;
+  using std::cyl_bessel_kf;
+  using std::cyl_bessel_kl;
+
+  // [sf.cmath.cyl.neumann], cylindrical Neumann functions
+  // cylindrical Bessel functions of the second kind
+  using std::cyl_neumann;
+  using std::cyl_neumannf;
+  using std::cyl_neumannl;
+
+  // [sf.cmath.ellint.1], incomplete elliptic integral of the first kind
+  using std::ellint_1;
+  using std::ellint_1f;
+  using std::ellint_1l;
+
+  // [sf.cmath.ellint.2], incomplete elliptic integral of the second kind
+  using std::ellint_2;
+  using std::ellint_2f;
+  using std::ellint_2l;
+
+  // [sf.cmath.ellint.3], incomplete elliptic integral of the third kind
+  using std::ellint_3;
+  using std::ellint_3f;
+  using std::ellint_3l;
+
+  // [sf.cmath.expint], exponential integral
+  using std::expint;
+  using std::expintf;
+  using std::expintl;
+
+  // [sf.cmath.hermite], Hermite polynomials
+  using std::hermite;
+  using std::hermitef;
+  using std::hermitel;
+
+  // [sf.cmath.laguerre], Laguerre polynomials
+  using std::laguerre;
+  using std::laguerref;
+  using std::laguerrel;
+
+  // [sf.cmath.legendre], Legendre polynomials
+  using std::legendre;
+  using std::legendref;
+  using std::legendrel;
+
+  // [sf.cmath.riemann.zeta], Riemann zeta function
+  using std::riemann_zeta;
+  using std::riemann_zetaf;
+  using std::riemann_zetal;
+
+  // [sf.cmath.sph.bessel], spherical Bessel functions of the first kind
+  using std::sph_bessel;
+  using std::sph_besself;
+  using std::sph_bessell;
+
+  // [sf.cmath.sph.legendre], spherical associated Legendre functions
+  using std::sph_legendre;
+  using std::sph_legendref;
+  using std::sph_legendrel;
+
+  // [sf.cmath.sph.neumann], spherical Neumann functions;
+  // spherical Bessel functions of the second kind
+  using std::sph_neumann;
+  using std::sph_neumannf;
+  using std::sph_neumannl;
+#endif
+} // namespace std
+
+// codecvt.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::codecvt_mode;
+
+  using std::codecvt_utf16;
+  using std::codecvt_utf8;
+  using std::codecvt_utf8_utf16;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// compare.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [cmp.categories], comparison category types
+  using std::partial_ordering;
+  using std::strong_ordering;
+  using std::weak_ordering;
+
+  // named comparison functions
+  using std::is_eq;
+  using std::is_gt;
+  using std::is_gteq;
+  using std::is_lt;
+  using std::is_lteq;
+  using std::is_neq;
+
+  // [cmp.common], common comparison category type
+  using std::common_comparison_category;
+  using std::common_comparison_category_t;
+
+  // [cmp.concept], concept three_way_comparable
+  using std::three_way_comparable;
+  using std::three_way_comparable_with;
+
+  // [cmp.result], result of three-way comparison
+  using std::compare_three_way_result;
+
+  using std::compare_three_way_result_t;
+
+  // [comparisons.three.way], class compare_three_way
+  using std::compare_three_way;
+
+  // [cmp.alg], comparison algorithms
+  inline namespace __cpo {
+    using std::__cpo::compare_partial_order_fallback;
+    using std::__cpo::compare_strong_order_fallback;
+    using std::__cpo::compare_weak_order_fallback;
+    using std::__cpo::partial_order;
+    using std::__cpo::strong_order;
+    using std::__cpo::weak_order;
+  } // namespace __cpo
+
+} // namespace std
+
+// complex.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [complex], class template complex
+  using std::complex;
+
+  // [complex.ops], operators
+  using std::operator+;
+  using std::operator-;
+  using std::operator*;
+  using std::operator/;
+
+  using std::operator==;
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::operator>>;
+  using std::operator<<;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+
+  // [complex.value.ops], values
+  using std::imag;
+  using std::real;
+
+  using std::abs;
+  using std::arg;
+  using std::norm;
+
+  using std::conj;
+  using std::polar;
+  using std::proj;
+
+  // [complex.transcendentals], transcendentals
+  using std::acos;
+  using std::asin;
+  using std::atan;
+
+  using std::acosh;
+  using std::asinh;
+  using std::atanh;
+
+  using std::cos;
+  using std::cosh;
+  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;
+
+  // [complex.literals], complex literals
+  inline namespace literals {
+    inline namespace complex_literals {
+      using std::operator""il;
+      using std::operator""i;
+      using std::operator""if;
+    } // namespace complex_literals
+  }   // namespace literals
+
+} // namespace std
+
+// concepts.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [concepts.lang], language-related concepts
+  // [concept.same], concept same_as
+  using std::same_as;
+
+  // [concept.derived], concept derived_from
+  using std::derived_from;
+
+  // [concept.convertible], concept convertible_to
+  using std::convertible_to;
+
+  // [concept.commonref], concept common_reference_with
+  using std::common_reference_with;
+
+  // [concept.common], concept common_with
+  using std::common_with;
+
+  // [concepts.arithmetic], arithmetic concepts
+  using std::floating_point;
+  using std::integral;
+  using std::signed_integral;
+  using std::unsigned_integral;
+
+  // [concept.assignable], concept assignable_from
+  using std::assignable_from;
+
+  // [concept.swappable], concept swappable
+  namespace ranges {
+    inline namespace __cpo {
+      using std::ranges::__cpo::swap;
+    }
+  } // namespace ranges
+
+  using std::swappable;
+  using std::swappable_with;
+
+  // [concept.destructible], concept destructible
+  using std::destructible;
+
+  // [concept.constructible], concept constructible_from
+  using std::constructible_from;
+
+  // [concept.default.init], concept default_initializable
+  using std::default_initializable;
+
+  // [concept.moveconstructible], concept move_constructible
+  using std::move_constructible;
+
+  // [concept.copyconstructible], concept copy_constructible
+  using std::copy_constructible;
+
+  // [concepts.compare], comparison concepts
+  // [concept.equalitycomparable], concept equality_comparable
+  using std::equality_comparable;
+  using std::equality_comparable_with;
+
+  // [concept.totallyordered], concept totally_ordered
+  using std::totally_ordered;
+  using std::totally_ordered_with;
+
+  // [concepts.object], object concepts
+  using std::copyable;
+  using std::movable;
+  using std::regular;
+  using std::semiregular;
+
+  // [concepts.callable], callable concepts
+  // [concept.invocable], concept invocable
+  using std::invocable;
+
+  // [concept.regularinvocable], concept regular_invocable
+  using std::regular_invocable;
+
+  // [concept.predicate], concept predicate
+  using std::predicate;
+
+  // [concept.relation], concept relation
+  using std::relation;
+
+  // [concept.equiv], concept equivalence_relation
+  using std::equivalence_relation;
+
+  // [concept.strictweakorder], concept strict_weak_order
+  using std::strict_weak_order;
+
+} // namespace std
+
+// condition_variable.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  // [thread.condition.condvar], class condition_variable
+  using std::condition_variable;
+  // [thread.condition.condvarany], class condition_variable_any
+  using std::condition_variable_any;
+
+  // [thread.condition.nonmember], non-member functions
+  using std::notify_all_at_thread_exit;
+
+  using std::cv_status;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// coroutine.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+
+  // [coroutine.traits], coroutine traits
+  using std::coroutine_traits;
+
+  // [coroutine.handle], coroutine handle
+  using std::coroutine_handle;
+
+  // [coroutine.handle.compare], comparison operators
+  using std::operator==;
+  using std::operator<=>;
+
+  // [coroutine.handle.hash], hash support
+  using std::hash;
+
+  // [coroutine.noop], no-op coroutines
+  using std::noop_coroutine;
+  using std::noop_coroutine_handle;
+  using std::noop_coroutine_promise;
+
+  // [coroutine.trivial.awaitables], trivial awaitables
+  using std::suspend_always;
+  using std::suspend_never;
+} // namespace std
+
+// csetjmp.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::jmp_buf;
+  using std::longjmp;
+} // namespace std
+
+// csignal.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::sig_atomic_t;
+
+  // [support.signal], signal handlers
+  using std::signal;
+
+  using std::raise;
+
+} // namespace std
+
+// cstdarg.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::va_list;
+} // namespace std
+
+// cstddef.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::max_align_t;
+  using std::nullptr_t;
+  using std::ptrdiff_t;
+  using std::size_t;
+
+  using std::byte;
+
+  // [support.types.byteops], byte type operations
+  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::to_integer;
+} // namespace std
+
+// cstdint.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // signed
+  using std::int8_t _LIBCPP_USING_IF_EXISTS;
+  using std::int16_t _LIBCPP_USING_IF_EXISTS;
+  using std::int32_t _LIBCPP_USING_IF_EXISTS;
+  using std::int64_t _LIBCPP_USING_IF_EXISTS;
+
+  using std::int_fast16_t;
+  using std::int_fast32_t;
+  using std::int_fast64_t;
+  using std::int_fast8_t;
+
+  using std::int_least16_t;
+  using std::int_least32_t;
+  using std::int_least64_t;
+  using std::int_least8_t;
+
+  using std::intmax_t;
+
+  using std::intptr_t _LIBCPP_USING_IF_EXISTS;
+
+  // unsigned
+  using std::uint8_t _LIBCPP_USING_IF_EXISTS;
+  using std::uint16_t _LIBCPP_USING_IF_EXISTS;
+  using std::uint32_t _LIBCPP_USING_IF_EXISTS;
+  using std::uint64_t _LIBCPP_USING_IF_EXISTS;
+
+  using std::uint_fast16_t;
+  using std::uint_fast32_t;
+  using std::uint_fast64_t;
+  using std::uint_fast8_t;
+
+  using std::uint_least16_t;
+  using std::uint_least32_t;
+  using std::uint_least64_t;
+  using std::uint_least8_t;
+
+  using std::uintmax_t;
+
+  using std::uintptr_t _LIBCPP_USING_IF_EXISTS;
+} // namespace std
+
+// cstdio.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::FILE;
+  using std::fpos_t;
+  using std::size_t;
+
+  using std::clearerr;
+  using std::fclose;
+  using std::feof;
+  using std::ferror;
+  using std::fflush;
+  using std::fgetc;
+  using std::fgetpos;
+  using std::fgets;
+  using std::fopen;
+  using std::fprintf;
+  using std::fputc;
+  using std::fputs;
+  using std::fread;
+  using std::freopen;
+  using std::fscanf;
+  using std::fseek;
+  using std::fsetpos;
+  using std::ftell;
+  using std::fwrite;
+  using std::getc;
+  using std::getchar;
+  using std::perror;
+  using std::printf;
+  using std::putc;
+  using std::putchar;
+  using std::puts;
+  using std::remove;
+  using std::rename;
+  using std::rewind;
+  using std::scanf;
+  using std::setbuf;
+  using std::setvbuf;
+  using std::snprintf;
+  using std::sprintf;
+  using std::sscanf;
+  using std::tmpfile;
+  using std::tmpnam;
+  using std::ungetc;
+  using std::vfprintf;
+  using std::vfscanf;
+  using std::vprintf;
+  using std::vscanf;
+  using std::vsnprintf;
+  using std::vsprintf;
+  using std::vsscanf;
+} // namespace std
+
+// cstdlib.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::div_t;
+  using std::ldiv_t;
+  using std::lldiv_t;
+  using std::size_t;
+
+  // [support.start.term], start and termination
+  using std::_Exit;
+  using std::abort;
+  using std::at_quick_exit;
+  using std::atexit;
+  using std::exit;
+  using std::quick_exit;
+
+  using std::getenv;
+  using std::system;
+
+  // [c.malloc], C library memory allocation
+  using std::aligned_alloc;
+  using std::calloc;
+  using std::free;
+  using std::malloc;
+  using std::realloc;
+
+  using std::atof;
+  using std::atoi;
+  using std::atol;
+  using std::atoll;
+  using std::strtod;
+  using std::strtof;
+  using std::strtol;
+  using std::strtold;
+  using std::strtoll;
+  using std::strtoul;
+  using std::strtoull;
+
+  // [c.mb.wcs], multibyte / wide string and character conversion functions
+  using std::mblen;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::mbstowcs;
+  using std::mbtowc;
+  using std::wcstombs;
+  using std::wctomb;
+#endif
+  // [alg.c.library], C standard library algorithms
+  using std::bsearch;
+  using std::qsort;
+
+  // [c.math.rand], low-quality random number generation
+  using std::rand;
+  using std::srand;
+
+  // [c.math.abs], absolute values
+  using std::abs;
+
+  using std::labs;
+  using std::llabs;
+
+  using std::div;
+  using std::ldiv;
+  using std::lldiv;
+} // namespace std
+
+// cstring.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::size_t;
+
+  using std::memchr;
+  using std::memcmp;
+  using std::memcpy;
+  using std::memmove;
+  using std::memset;
+  using std::strcat;
+  using std::strchr;
+  using std::strcmp;
+  using std::strcoll;
+  using std::strcpy;
+  using std::strcspn;
+  using std::strerror;
+  using std::strlen;
+  using std::strncat;
+  using std::strncmp;
+  using std::strncpy;
+  using std::strpbrk;
+  using std::strrchr;
+  using std::strspn;
+  using std::strstr;
+  using std::strtok;
+  using std::strxfrm;
+} // namespace std
+
+// ctime.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::clock_t;
+  using std::size_t;
+  using std::time_t;
+
+  using std::timespec;
+  using std::tm;
+
+  using std::asctime;
+  using std::clock;
+  using std::ctime;
+  using std::difftime;
+  using std::gmtime;
+  using std::localtime;
+  using std::mktime;
+  using std::strftime;
+  using std::time;
+  using std::timespec_get;
+} // namespace std
+
+// cuchar.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // Note the Standard does not mark these symbols optional, but libc++'s header
+  // does. So this seems strictly not to be conforming.
+
+  // mbstate_t is conditionally here, but always present in cwchar.cppm. To avoid
+  // conflicing declarations omit the using here.
+
+  // size_t is conditionally here, but always present in cstddef.cppm. To avoid
+  // conflicing declarations omit the using here.
+
+#if !defined(_LIBCPP_HAS_NO_C8RTOMB_MBRTOC8)
+  using std::mbrtoc8 _LIBCPP_USING_IF_EXISTS;
+  using std::c8rtomb _LIBCPP_USING_IF_EXISTS;
+#endif
+  using std::mbrtoc16 _LIBCPP_USING_IF_EXISTS;
+  using std::c16rtomb _LIBCPP_USING_IF_EXISTS;
+  using std::mbrtoc32 _LIBCPP_USING_IF_EXISTS;
+  using std::c32rtomb _LIBCPP_USING_IF_EXISTS;
+} // namespace std
+
+// cwchar.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::mbstate_t;
+  using std::size_t;
+  using std::wint_t;
+
+  using std::tm;
+
+  using std::btowc;
+  using std::fgetwc;
+  using std::fgetws;
+  using std::fputwc;
+  using std::fputws;
+  using std::fwide;
+  using std::fwprintf;
+  using std::fwscanf;
+  using std::getwc;
+  using std::getwchar;
+  using std::putwc;
+  using std::putwchar;
+  using std::swprintf;
+  using std::swscanf;
+  using std::ungetwc;
+  using std::vfwprintf;
+  using std::vfwscanf;
+  using std::vswprintf;
+  using std::vswscanf;
+  using std::vwprintf;
+  using std::vwscanf;
+  using std::wcscat;
+  using std::wcschr;
+  using std::wcscmp;
+  using std::wcscoll;
+  using std::wcscpy;
+  using std::wcscspn;
+  using std::wcsftime;
+  using std::wcslen;
+  using std::wcsncat;
+  using std::wcsncmp;
+  using std::wcsncpy;
+  using std::wcspbrk;
+  using std::wcsrchr;
+  using std::wcsspn;
+  using std::wcsstr;
+  using std::wcstod;
+  using std::wcstof;
+  using std::wcstok;
+  using std::wcstol;
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoul;
+  using std::wcstoull;
+  using std::wcsxfrm;
+  using std::wctob;
+  using std::wmemchr;
+  using std::wmemcmp;
+  using std::wmemcpy;
+  using std::wmemmove;
+  using std::wmemset;
+  using std::wprintf;
+  using std::wscanf;
+
+  // [c.mb.wcs], multibyte / wide string and character conversion functions
+  using std::mbrlen;
+  using std::mbrtowc;
+  using std::mbsinit;
+  using std::mbsrtowcs;
+  using std::wcrtomb;
+  using std::wcsrtombs;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+} // namespace std
+
+// cwctype.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wctrans_t;
+  using std::wctype_t;
+  using std::wint_t;
+
+  using std::iswalnum;
+  using std::iswalpha;
+  using std::iswblank;
+  using std::iswcntrl;
+  using std::iswctype;
+  using std::iswdigit;
+  using std::iswgraph;
+  using std::iswlower;
+  using std::iswprint;
+  using std::iswpunct;
+  using std::iswspace;
+  using std::iswupper;
+  using std::iswxdigit;
+  using std::towctrans;
+  using std::towlower;
+  using std::towupper;
+  using std::wctrans;
+  using std::wctype;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+} // namespace std
+
+// deque.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [deque], class template deque
+  using std::deque;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::swap;
+
+  // [deque.erasure], erasure
+  using std::erase;
+  using std::erase_if;
+
+  namespace pmr {
+    using std::pmr::deque;
+  }
+} // namespace std
+
+// exception.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-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;
+} // namespace std
+
+// execution.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+export namespace std {
+  // [execpol.type], execution policy type trait
+  using std::is_execution_policy;
+  using std::is_execution_policy_v;
+} // namespace std
+
+export namespace std::execution {
+  // [execpol.seq], sequenced execution policy
+  using std::execution::sequenced_policy;
+
+  // [execpol.par], parallel execution policy
+  using std::execution::parallel_policy;
+
+  // [execpol.parunseq], parallel and unsequenced execution policy
+  using std::execution::parallel_unsequenced_policy;
+
+  // [execpol.unseq], unsequenced execution policy
+  using std::execution::unsequenced_policy;
+
+  // [execpol.objects], execution policy objects
+  using std::execution::par;
+  using std::execution::par_unseq;
+  using std::execution::seq;
+  using std::execution::unseq;
+} // namespace std::execution
+#endif // _LIBCPP_ENABLE_EXPERIMENTAL
+
+// expected.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if _LIBCPP_STD_VER >= 23
+  // [expected.unexpected], class template unexpected
+  using std::unexpected;
+
+  // [expected.bad], class template bad_expected_access
+  using std::bad_expected_access;
+
+  // in-place construction of unexpected values
+  using std::unexpect;
+  using std::unexpect_t;
+
+  // [expected.expected], class template expected
+  using std::expected;
+#endif // _LIBCPP_STD_VER >= 23
+} // namespace std
+
+// filesystem.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std::filesystem {
+  // [fs.class.path], paths
+  using std::filesystem::path;
+
+  // [fs.path.nonmember], path non-member functions
+  using std::filesystem::hash_value;
+  using std::filesystem::swap;
+
+  // [fs.class.filesystem.error], filesystem errors
+  using std::filesystem::filesystem_error;
+
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
+  // [fs.class.directory.entry], directory entries
+  using std::filesystem::directory_entry;
+
+  // [fs.class.directory.iterator], directory iterators
+  using std::filesystem::directory_iterator;
+
+  // [fs.dir.itr.nonmembers], range access for directory iterators
+  using std::filesystem::begin;
+  using std::filesystem::end;
+
+  // [fs.class.rec.dir.itr], recursive directory iterators
+  using std::filesystem::recursive_directory_iterator;
+#endif // _LIBCPP_HAS_NO_FILESYSTEM
+
+  // [fs.rec.dir.itr.nonmembers], range access for recursive directory iterators
+
+  // [fs.class.file.status], file status
+  using std::filesystem::file_status;
+  using std::filesystem::space_info;
+
+  // [fs.enum], enumerations
+  using std::filesystem::copy_options;
+  using std::filesystem::directory_options;
+  using std::filesystem::file_type;
+  using std::filesystem::perm_options;
+  using std::filesystem::perms;
+
+  using std::filesystem::file_time_type;
+
+  // several of these enums are a bitmask type.
+  // [bitmask.types] specified operators
+  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~;
+
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
+  // [fs.op.funcs], filesystem operations
+  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::weakly_canonical;
+#endif // _LIBCPP_HAS_NO_FILESYSTEM
+
+  // [depr.fs.path.factory]
+  using std::filesystem::u8path;
+} // namespace std::filesystem
+
+// [fs.path.hash], hash support
+export namespace std {
+  using std::hash;
+}
+
+export namespace std::ranges {
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
+  using std::ranges::enable_borrowed_range;
+  using std::ranges::enable_view;
+#endif // _LIBCPP_HAS_NO_FILESYSTEM
+} // namespace std::ranges
+
+// flat_map.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+  // [flat.map], class template flat_­map
+  using std::flat_map;
+
+  using std::sorted_unique;
+  using std::sorted_unique_t;
+
+  using std::uses_allocator;
+
+  // [flat.map.erasure], erasure for flat_­map
+  using std::erase_if;
+
+  // [flat.multimap], class template flat_­multimap
+  using std::flat_multimap;
+
+  using std::sorted_equivalent;
+  using std::sorted_equivalent_t;
+
+  // [flat.multimap.erasure], erasure for flat_­multimap
+#endif
+} // namespace std
+
+// flat_set.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+  // [flat.set], class template flat_­set
+  using std::flat_set;
+
+  using std::sorted_unique;
+  using std::sorted_unique_t;
+
+  using std::uses_allocator;
+
+  // [flat.set.erasure], erasure for flat_­set
+  using std::erase_if;
+
+  // [flat.multiset], class template flat_­multiset
+  using std::flat_multiset;
+
+  using std::sorted_equivalent;
+  using std::sorted_equivalent_t;
+#endif
+} // namespace std
+
+// format.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [format.context], class template basic_format_context
+  using std::basic_format_context;
+  using std::format_context;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_context;
+#endif
+
+  // [format.args], class template basic_format_args
+  using std::basic_format_args;
+  using std::format_args;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_args;
+#endif
+
+  // [format.fmt.string], class template basic_format_string
+  using std::basic_format_string;
+  using std::format_string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_string;
+#endif
+
+  // [format.functions], formatting functions
+  using std::format;
+  using std::format_to;
+  using std::vformat;
+  using std::vformat_to;
+
+  using std::format_to_n;
+  using std::format_to_n_result;
+  using std::formatted_size;
+
+  // [format.formatter], formatter
+  using std::formatter;
+
+#if _LIBCPP_STD_VER >= 23
+  // [format.formattable], concept formattable
+  using std::formattable;
+#endif
+
+  // [format.parse.ctx], class template basic_format_parse_context
+  using std::basic_format_parse_context;
+  using std::format_parse_context;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wformat_parse_context;
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+  // [format.range], formatting of ranges
+  // [format.range.fmtkind], variable template format_kind
+  using std::format_kind;
+  using std::range_format;
+
+  // [format.range.formatter], class template range_formatter
+  using std::range_formatter;
+#endif // _LIBCPP_STD_VER >= 23
+
+  // [format.arg], class template basic_format_arg
+  using std::basic_format_arg;
+  using std::visit_format_arg;
+
+  // [format.arg.store], class template format-arg-store
+  using std::make_format_args;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::make_wformat_args;
+#endif
+
+  // [format.error], class format_error
+  using std::format_error;
+} // namespace std
+
+// forward_list.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [forward.list], class template forward_list
+  using std::forward_list;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::swap;
+
+  // [forward.list.erasure], erasure
+  using std::erase;
+  using std::erase_if;
+
+  namespace pmr {
+    using std::pmr::forward_list;
+  }
+} // namespace std
+
+// fstream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::basic_filebuf;
+
+#  ifndef _LIBCPP_HAS_NO_FILESYSTEM
+  using std::swap;
+#  endif
+
+  using std::filebuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wfilebuf;
+#  endif
+
+  using std::basic_ifstream;
+
+  using std::ifstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wifstream;
+#  endif
+
+  using std::basic_ofstream;
+
+  using std::ofstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wofstream;
+#  endif
+
+  using std::basic_fstream;
+
+  using std::fstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wfstream;
+#  endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// functional.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [func.invoke], invoke
+  using std::invoke;
+#if _LIBCPP_STD_VER >= 23
+  using std::invoke_r;
+#endif
+
+  // [refwrap], reference_wrapper
+  using std::reference_wrapper;
+
+  using std::cref;
+  using std::ref;
+
+  // [arithmetic.operations], arithmetic operations
+  using std::divides;
+  using std::minus;
+  using std::modulus;
+  using std::multiplies;
+  using std::negate;
+  using std::plus;
+  // [comparisons], comparisons
+  using std::equal_to;
+  using std::greater;
+  using std::greater_equal;
+  using std::less;
+  using std::less_equal;
+  using std::not_equal_to;
+
+  // [comparisons.three.way], class compare_three_way
+  using std::compare_three_way;
+
+  // [logical.operations], logical operations
+  using std::logical_and;
+  using std::logical_not;
+  using std::logical_or;
+
+  // [bitwise.operations], bitwise operations
+  using std::bit_and;
+  using std::bit_not;
+  using std::bit_or;
+  using std::bit_xor;
+
+  // [func.identity], identity
+  using std::identity;
+
+  // [func.not.fn], function template not_fn
+  using std::not_fn;
+
+  // [func.bind.partial], function templates bind_front and bind_back
+  // using std::bind_back;
+  using std::bind_front;
+
+  // [func.bind], bind
+  using std::is_bind_expression;
+  using std::is_bind_expression_v;
+  using std::is_placeholder;
+  using std::is_placeholder_v;
+
+  using std::bind;
+
+  namespace placeholders {
+    // M is the implementation-defined number of 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;
+  } // namespace placeholders
+
+  // [func.memfn], member function adaptors
+  using std::mem_fn;
+
+  // [func.wrap], polymorphic function wrappers
+  using std::bad_function_call;
+
+  using std::function;
+
+  using std::swap;
+
+  using std::operator==;
+
+  // [func.wrap.move], move only wrapper
+  // using std::move_only_function;
+
+  // [func.search], searchers
+  using std::default_searcher;
+
+  using std::boyer_moore_searcher;
+
+  using std::boyer_moore_horspool_searcher;
+
+  // [unord.hash], class template hash
+  using std::hash;
+
+  namespace ranges {
+    // [range.cmp], concept-constrained comparisons
+    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;
+  } // namespace ranges
+} // namespace std
+
+// future.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  using std::future_errc;
+  using std::future_status;
+  using std::launch;
+
+  // launch is a bitmask type.
+  // [bitmask.types] specified operators
+  using std::operator&;
+  using std::operator&=;
+  using std::operator^;
+  using std::operator^=;
+  using std::operator|;
+  using std::operator|=;
+  using std::operator~;
+
+  // [futures.errors], error handling
+  using std::is_error_code_enum;
+  using std::make_error_code;
+  using std::make_error_condition;
+
+  using std::future_category;
+
+  // [futures.future.error], class future_error
+  using std::future_error;
+
+  // [futures.promise], class template promise
+  using std::promise;
+
+  using std::swap;
+
+  using std::uses_allocator;
+
+  // [futures.unique.future], class template future
+  using std::future;
+
+  // [futures.shared.future], class template shared_future
+  using std::shared_future;
+
+  // [futures.task], class template packaged_task
+  using std::packaged_task;
+
+  // [futures.async], function template async
+  using std::async;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// generator.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+  using std::generator;
+#endif
+} // namespace std
+
+// hazard_pointer.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+#  if _LIBCPP_STD_VER >= 23
+  // 4.1.3, class template hazard_pointer_obj_base
+  using std::hazard_pointer_obj_base;
+  // 4.1.4, class hazard_pointer
+  using std::hazard_pointer;
+  // 4.1.5, Construct non-empty hazard_pointer
+  using std::make_hazard_pointer;
+  // 4.1.6, Hazard pointer swap
+  using std::swap;
+#  endif // _LIBCPP_STD_VER >= 23
+#endif
+} // namespace std
+
+// initializer_list.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::initializer_list;
+
+  // [support.initlist.range], initializer list range access
+  using std::begin;
+  using std::end;
+} // namespace std
+
+// iomanip.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::get_money;
+  using std::get_time;
+  using std::put_money;
+  using std::put_time;
+  using std::resetiosflags;
+  using std::setbase;
+  using std::setfill;
+  using std::setiosflags;
+  using std::setprecision;
+  using std::setw;
+
+  using std::quoted;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// ios.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::fpos;
+  // based on [tab:fpos.operations]
+  using std::operator!=; // Note not affected by P1614, seems like a bug.
+  using std::operator-;
+  using std::operator==;
+
+  using std::streamoff;
+  using std::streamsize;
+
+  using std::basic_ios;
+  using std::ios_base;
+
+  // [std.ios.manip], manipulators
+  using std::boolalpha;
+  using std::noboolalpha;
+
+  using std::noshowbase;
+  using std::showbase;
+
+  using std::noshowpoint;
+  using std::showpoint;
+
+  using std::noshowpos;
+  using std::showpos;
+
+  using std::noskipws;
+  using std::skipws;
+
+  using std::nouppercase;
+  using std::uppercase;
+
+  using std::nounitbuf;
+  using std::unitbuf;
+
+  // [adjustfield.manip], adjustfield
+  using std::internal;
+  using std::left;
+  using std::right;
+
+  // [basefield.manip], basefield
+  using std::dec;
+  using std::hex;
+  using std::oct;
+
+  // [floatfield.manip], floatfield
+  using std::defaultfloat;
+  using std::fixed;
+  using std::hexfloat;
+  using std::scientific;
+
+  // [error.reporting], error reporting
+  using std::io_errc;
+
+  using std::iostream_category;
+  using std::is_error_code_enum;
+  using std::make_error_code;
+  using std::make_error_condition;
+
+  // [iosfwd.syn]
+  using std::ios;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wios;
+#  endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// iosfwd.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::streampos;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstreampos;
+#endif
+  using std::u16streampos;
+  using std::u32streampos;
+  using std::u8streampos;
+
+#ifdef _LIBCPP_HAS_YES_SYNCSTREAM
+  using std::basic_osyncstream;
+  using std::basic_syncbuf;
+#endif
+
+  using std::istreambuf_iterator;
+  using std::ostreambuf_iterator;
+
+#ifdef _LIBCPP_HAS_YES_SYNCSTREAM
+  using std::osyncstream;
+  using std::syncbuf;
+#endif
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#ifdef _LIBCPP_HAS_YES_SYNCSTREAM
+  using std::wosyncstream;
+  using std::wsyncbuf;
+#endif
+#endif
+
+  using std::fpos;
+} // namespace std
+
+// iostream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::cerr;
+  using std::cin;
+  using std::clog;
+  using std::cout;
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wcerr;
+  using std::wcin;
+  using std::wclog;
+  using std::wcout;
+#  endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// istream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::basic_istream;
+
+  using std::istream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wistream;
+#  endif
+
+  using std::basic_iostream;
+
+  using std::iostream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wiostream;
+#  endif
+
+  using std::ws;
+
+  using std::operator>>;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// iterator.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [iterator.assoc.types], associated types
+  // [incrementable.traits], incrementable traits
+  using std::incrementable_traits;
+  using std::iter_difference_t;
+
+  using std::indirectly_readable_traits;
+  using std::iter_value_t;
+
+  // [iterator.traits], iterator traits
+  using std::iterator_traits;
+
+  using std::iter_reference_t;
+
+  namespace ranges {
+    // [iterator.cust], customization point objects
+    inline namespace __cpo {
+      // [iterator.cust.move], ranges::iter_move
+      using std::ranges::__cpo::iter_move;
+
+      // [iterator.cust.swap], ranges::iter_swap
+      using std::ranges::__cpo::iter_swap;
+    } // namespace __cpo
+  }   // namespace ranges
+
+  using std::iter_rvalue_reference_t;
+
+  // [iterator.concepts], iterator concepts
+  // [iterator.concept.readable], concept indirectly_readable
+  using std::indirectly_readable;
+
+  using std::iter_common_reference_t;
+
+  // [iterator.concept.writable], concept indirectly_writable
+  using std::indirectly_writable;
+
+  // [iterator.concept.winc], concept weakly_incrementable
+  using std::weakly_incrementable;
+
+  // [iterator.concept.inc], concept incrementable
+  using std::incrementable;
+
+  // [iterator.concept.iterator], concept input_or_output_iterator
+  using std::input_or_output_iterator;
+
+  // [iterator.concept.sentinel], concept sentinel_for
+  using std::sentinel_for;
+
+  // [iterator.concept.sizedsentinel], concept sized_sentinel_for
+  using std::disable_sized_sentinel_for;
+
+  using std::sized_sentinel_for;
+
+  // [iterator.concept.input], concept input_iterator
+  using std::input_iterator;
+
+  // [iterator.concept.output], concept output_iterator
+  using std::output_iterator;
+
+  // [iterator.concept.forward], concept forward_iterator
+  using std::forward_iterator;
+
+  // [iterator.concept.bidir], concept bidirectional_iterator
+  using std::bidirectional_iterator;
+
+  // [iterator.concept.random.access], concept random_access_iterator
+  using std::random_access_iterator;
+
+  // [iterator.concept.contiguous], concept contiguous_iterator
+  using std::contiguous_iterator;
+
+  // [indirectcallable], indirect callable requirements
+  // [indirectcallable.indirectinvocable], indirect callables
+  using std::indirectly_unary_invocable;
+
+  using std::indirectly_regular_unary_invocable;
+
+  using std::indirect_unary_predicate;
+
+  using std::indirect_binary_predicate;
+
+  using std::indirect_equivalence_relation;
+
+  using std::indirect_strict_weak_order;
+
+  using std::indirect_result_t;
+
+  // [projected], projected
+  using std::projected;
+
+  // [alg.req], common algorithm requirements
+  // [alg.req.ind.move], concept indirectly_movable
+  using std::indirectly_movable;
+
+  using std::indirectly_movable_storable;
+
+  // [alg.req.ind.copy], concept indirectly_copyable
+  using std::indirectly_copyable;
+
+  using std::indirectly_copyable_storable;
+
+  // [alg.req.ind.swap], concept indirectly_swappable
+  using std::indirectly_swappable;
+
+  // [alg.req.ind.cmp], concept indirectly_comparable
+  using std::indirectly_comparable;
+
+  // [alg.req.permutable], concept permutable
+  using std::permutable;
+
+  // [alg.req.mergeable], concept mergeable
+  using std::mergeable;
+
+  // [alg.req.sortable], concept sortable
+  using std::sortable;
+
+  // [iterator.primitives], primitives
+  // [std.iterator.tags], iterator tags
+  using std::bidirectional_iterator_tag;
+  using std::contiguous_iterator_tag;
+  using std::forward_iterator_tag;
+  using std::input_iterator_tag;
+  using std::output_iterator_tag;
+  using std::random_access_iterator_tag;
+
+  // [iterator.operations], iterator operations
+  using std::advance;
+  using std::distance;
+  using std::next;
+  using std::prev;
+
+  // [range.iter.ops], range iterator operations
+  namespace ranges {
+    // [range.iter.op.advance], ranges​::​advance
+    using std::ranges::advance;
+
+    // [range.iter.op.distance], ranges​::​distance
+    using std::ranges::distance;
+
+    // [range.iter.op.next], ranges​::​next
+    using std::ranges::next;
+
+    // [range.iter.op.prev], ranges​::​prev
+    using std::ranges::prev;
+  } // namespace ranges
+
+  // [predef.iterators], predefined iterators and sentinels
+  // [reverse.iterators], reverse iterators
+  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::make_reverse_iterator;
+
+  // using std::disable_sized_sentinel_for;
+
+  // [insert.iterators], insert iterators
+  using std::back_insert_iterator;
+  using std::back_inserter;
+
+  using std::front_insert_iterator;
+  using std::front_inserter;
+
+  using std::insert_iterator;
+  using std::inserter;
+
+  // [const.iterators], constant iterators and sentinels
+  // [const.iterators.alias], alias templates
+  //  using std::const_iterator;
+  //  using std::const_sentinel;
+  //  using std::iter_const_reference_t;
+
+  // [const.iterators.iterator], class template basic_const_iterator
+  //  using std::basic_const_iterator;
+
+  // using std::common_type;
+
+  //  using std::make_const_iterator;
+
+  // [move.iterators], move iterators and sentinels
+  using std::move_iterator;
+
+  using std::make_move_iterator;
+
+  using std::move_sentinel;
+
+  using std::common_iterator;
+
+  // [default.sentinel], default sentinel
+  using std::default_sentinel;
+  using std::default_sentinel_t;
+
+  // [iterators.counted], counted iterators
+  using std::counted_iterator;
+
+  // [unreachable.sentinel], unreachable sentinel
+  using std::unreachable_sentinel;
+  using std::unreachable_sentinel_t;
+
+  // [stream.iterators], stream iterators
+  using std::istream_iterator;
+
+  using std::ostream_iterator;
+
+  using std::istreambuf_iterator;
+  using std::ostreambuf_iterator;
+
+  // [iterator.range], range access
+  using std::begin;
+  using std::cbegin;
+  using std::cend;
+  using std::crbegin;
+  using std::crend;
+  using std::end;
+  using std::rbegin;
+  using std::rend;
+
+  using std::empty;
+  using std::size;
+  using std::ssize;
+
+  using std::data;
+
+  // [depr.iterator]
+  using std::iterator;
+} // namespace std
+
+// latch.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  using std::latch;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// limits.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [fp.style], floating-point type properties
+  using std::float_denorm_style;
+  using std::float_round_style;
+
+  // [numeric.limits], class template numeric_­limits
+  using std::numeric_limits;
+} // namespace std
+
+// list.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [list], class template list
+  using std::list;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::swap;
+
+  // [list.erasure], erasure
+  using std::erase;
+  using std::erase_if;
+
+  namespace pmr {
+    using std::pmr::list;
+  }
+} // namespace std
+
+// locale.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  // [locale], locale
+  using std::has_facet;
+  using std::locale;
+  using std::use_facet;
+
+  // [locale.convenience], convenience interfaces
+  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::tolower;
+  using std::toupper;
+
+  // [category.ctype], ctype
+  using std::codecvt;
+  using std::codecvt_base;
+  using std::codecvt_byname;
+  using std::ctype;
+  using std::ctype_base;
+  using std::ctype_byname;
+
+  // [category.numeric], numeric
+  using std::num_get;
+  using std::num_put;
+  using std::numpunct;
+  using std::numpunct_byname;
+
+  // [category.collate], collation
+  using std::collate;
+  using std::collate_byname;
+
+  // [category.time], date and time
+  using std::time_base;
+  using std::time_get;
+  using std::time_get_byname;
+  using std::time_put;
+  using std::time_put_byname;
+
+  // [category.monetary], money
+  using std::money_base;
+  using std::money_get;
+  using std::money_put;
+  using std::moneypunct;
+  using std::moneypunct_byname;
+
+  // [category.messages], message retrieval
+  using std::messages;
+  using std::messages_base;
+  using std::messages_byname;
+
+  // [depr.conversions.buffer]
+  using std::wbuffer_convert;
+
+  // [depr.conversions.string]
+  using std::wstring_convert;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// map.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [map], class template map
+  using std::map;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::swap;
+
+  // [map.erasure], erasure for map
+  using std::erase_if;
+
+  // [multimap], class template multimap
+  using std::multimap;
+
+  namespace pmr {
+    using std::pmr::map;
+    using std::pmr::multimap;
+  } // namespace pmr
+} // namespace std
+
+// mdspan.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if _LIBCPP_STD_VER >= 23
+  // [mdspan.extents], class template extents
+  using std::extents;
+
+  // [mdspan.extents.dextents], alias template dextents
+  using std::dextents;
+
+  // [mdspan.layout], layout mapping
+  using std::layout_left;
+  using std::layout_right;
+#if _LIBCPP_VERSION >= 180000
+  using std::layout_stride;
+#endif
+
+  // [mdspan.accessor.default], class template default_accessor
+  using std::default_accessor;
+
+  // [mdspan.mdspan], class template mdspan
+  using std::mdspan;
+#endif // _LIBCPP_STD_VER >= 23
+} // namespace std
+
+// memory.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [pointer.traits], pointer traits
+  using std::pointer_traits;
+
+  // [pointer.conversion], pointer conversion
+  using std::to_address;
+
+  // [ptr.align], pointer alignment
+  using std::align;
+  using std::assume_aligned;
+
+  // [obj.lifetime], explicit lifetime management
+  //  using std::start_lifetime_as;
+  //  using std::start_lifetime_as_array;
+
+  // [allocator.tag], allocator argument tag
+  using std::allocator_arg;
+  using std::allocator_arg_t;
+
+  // [allocator.uses], uses_allocator
+  using std::uses_allocator;
+
+  // [allocator.uses.trait], uses_allocator
+  using std::uses_allocator_v;
+
+  // [allocator.uses.construction], uses-allocator construction
+  using std::uses_allocator_construction_args;
+
+  using std::make_obj_using_allocator;
+  using std::uninitialized_construct_using_allocator;
+
+  // [allocator.traits], allocator traits
+  using std::allocator_traits;
+
+#if _LIBCPP_STD_VER >= 23
+  using std::allocation_result;
+
+  using std::allocate_at_least;
+#endif
+
+  // [default.allocator], the default allocator
+  using std::allocator;
+  using std::operator==;
+
+  // [specialized.addressof], addressof
+  using std::addressof;
+
+  // [specialized.algorithms], specialized algorithms
+  // [special.mem.concepts], special memory concepts
+
+  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;
+  } // namespace ranges
+
+  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;
+  } // namespace ranges
+
+  using std::uninitialized_copy;
+  using std::uninitialized_copy_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_copy;
+    using std::ranges::uninitialized_copy_result;
+
+    using std::ranges::uninitialized_copy_n;
+    using std::ranges::uninitialized_copy_n_result;
+  } // namespace ranges
+
+  using std::uninitialized_move;
+  using std::uninitialized_move_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_move;
+    using std::ranges::uninitialized_move_result;
+
+    using std::ranges::uninitialized_move_n;
+    using std::ranges::uninitialized_move_n_result;
+  } // namespace ranges
+
+  using std::uninitialized_fill;
+  using std::uninitialized_fill_n;
+
+  namespace ranges {
+    using std::ranges::uninitialized_fill;
+    using std::ranges::uninitialized_fill_n;
+  } // namespace ranges
+
+  // [specialized.construct], construct_at
+  using std::construct_at;
+
+  namespace ranges {
+    using std::ranges::construct_at;
+  }
+  // [specialized.destroy], destroy
+  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;
+  } // namespace ranges
+
+  // [unique.ptr], class template unique_ptr
+  using std::default_delete;
+  using std::unique_ptr;
+
+  using std::make_unique;
+  using std::make_unique_for_overwrite;
+
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  using std::operator<<;
+
+  // [util.smartptr.weak.bad], class bad_weak_ptr
+  using std::bad_weak_ptr;
+
+  // [util.smartptr.shared], class template shared_ptr
+  using std::shared_ptr;
+
+  // [util.smartptr.shared.create], shared_ptr creation
+  using std::allocate_shared;
+  using std::allocate_shared_for_overwrite;
+  using std::make_shared;
+  using std::make_shared_for_overwrite;
+
+  // [util.smartptr.shared.spec], shared_ptr specialized algorithms
+  using std::swap;
+
+  // [util.smartptr.shared.cast], shared_ptr casts
+  using std::const_pointer_cast;
+  using std::dynamic_pointer_cast;
+  using std::reinterpret_pointer_cast;
+  using std::static_pointer_cast;
+
+  using std::get_deleter;
+
+  // [util.smartptr.shared.io], shared_ptr I/O
+
+  // [util.smartptr.weak], class template weak_ptr
+  using std::weak_ptr;
+
+  // [util.smartptr.weak.spec], weak_ptr specialized algorithms
+
+  // [util.smartptr.ownerless], class template owner_less
+  using std::owner_less;
+
+  // [util.smartptr.enab], class template enable_shared_from_this
+  using std::enable_shared_from_this;
+
+  // [util.smartptr.hash], hash support
+  using std::hash;
+
+  // [util.smartptr.atomic], atomic smart pointers
+  // using std::atomic;
+
+  // [out.ptr.t], class template out_ptr_t
+  //  using std::out_ptr_t;
+
+  // [out.ptr], function template out_ptr
+  //  using std::out_ptr;
+
+  // [inout.ptr.t], class template inout_ptr_t
+  //  using std::inout_ptr_t;
+
+  // [inout.ptr], function template inout_ptr
+  //  using std::inout_ptr;
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+  // [depr.util.smartptr.shared.atomic]
+  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::atomic_exchange;
+  using std::atomic_exchange_explicit;
+
+  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;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// memory_resource.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std::pmr {
+  // [mem.res.class], class memory_resource
+  using std::pmr::memory_resource;
+
+  using std::pmr::operator==;
+
+  // [mem.poly.allocator.class], class template polymorphic_allocator
+  using std::pmr::polymorphic_allocator;
+
+  // [mem.res.global], global memory resources
+  using std::pmr::get_default_resource;
+  using std::pmr::new_delete_resource;
+  using std::pmr::null_memory_resource;
+  using std::pmr::set_default_resource;
+
+  // [mem.res.pool], pool resource classes
+  using std::pmr::monotonic_buffer_resource;
+  using std::pmr::pool_options;
+  using std::pmr::synchronized_pool_resource;
+  using std::pmr::unsynchronized_pool_resource;
+} // namespace std::pmr
+
+// mutex.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  // [thread.mutex.class], class mutex
+  using std::mutex;
+  // [thread.mutex.recursive], class recursive_mutex
+  using std::recursive_mutex;
+  // [thread.timedmutex.class] class timed_mutex
+  using std::timed_mutex;
+  // [thread.timedmutex.recursive], class recursive_timed_mutex
+  using std::recursive_timed_mutex;
+
+  using std::adopt_lock_t;
+  using std::defer_lock_t;
+  using std::try_to_lock_t;
+
+  using std::adopt_lock;
+  using std::defer_lock;
+  using std::try_to_lock;
+
+  // [thread.lock], locks
+  using std::lock_guard;
+  using std::scoped_lock;
+  using std::unique_lock;
+
+  using std::swap;
+
+  // [thread.lock.algorithm], generic locking algorithms
+  using std::lock;
+  using std::try_lock;
+#endif // _LIBCPP_HAS_NO_THREADS
+
+  using std::once_flag;
+
+  using std::call_once;
+} // namespace std
+
+// new.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [alloc.errors], storage allocation errors
+  using std::bad_alloc;
+  using std::bad_array_new_length;
+
+  using std::destroying_delete;
+  using std::destroying_delete_t;
+
+  // global operator new control
+  using std::align_val_t;
+
+  using std::nothrow;
+  using std::nothrow_t;
+
+  using std::get_new_handler;
+  using std::new_handler;
+  using std::set_new_handler;
+
+  // [ptr.launder], pointer optimization barrier
+  using std::launder;
+#if 0
+  // [hardware.interference], hardware interference size
+  using std::hardware_constructive_interference_size;
+  using std::hardware_destructive_interference_size;
+#endif
+} // namespace std
+
+export {
+  using ::operator new;
+  using ::operator delete;
+  using ::operator new[];
+  using ::operator delete[];
+} // export
+
+// numbers.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std::numbers {
+  using std::numbers::e_v;
+  using std::numbers::egamma_v;
+  using std::numbers::inv_pi_v;
+  using std::numbers::inv_sqrt3_v;
+  using std::numbers::inv_sqrtpi_v;
+  using std::numbers::ln10_v;
+  using std::numbers::ln2_v;
+  using std::numbers::log10e_v;
+  using std::numbers::log2e_v;
+  using std::numbers::phi_v;
+  using std::numbers::pi_v;
+  using std::numbers::sqrt2_v;
+  using std::numbers::sqrt3_v;
+
+  using std::numbers::e;
+  using std::numbers::egamma;
+  using std::numbers::inv_pi;
+  using std::numbers::inv_sqrt3;
+  using std::numbers::inv_sqrtpi;
+  using std::numbers::ln10;
+  using std::numbers::ln2;
+  using std::numbers::log10e;
+  using std::numbers::log2e;
+  using std::numbers::phi;
+  using std::numbers::pi;
+  using std::numbers::sqrt2;
+  using std::numbers::sqrt3;
+} // namespace std::numbers
+
+// numeric.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [accumulate], accumulate
+  using std::accumulate;
+
+  // [reduce], reduce
+  using std::reduce;
+
+  // [inner.product], inner product
+  using std::inner_product;
+
+  // [transform.reduce], transform reduce
+  using std::transform_reduce;
+
+  // [partial.sum], partial sum
+  using std::partial_sum;
+
+  // [exclusive.scan], exclusive scan
+  using std::exclusive_scan;
+
+  // [inclusive.scan], inclusive scan
+  using std::inclusive_scan;
+
+  // [transform.exclusive.scan], transform exclusive scan
+  using std::transform_exclusive_scan;
+
+  // [transform.inclusive.scan], transform inclusive scan
+  using std::transform_inclusive_scan;
+
+  // [adjacent.difference], adjacent difference
+  using std::adjacent_difference;
+
+  // [numeric.iota], iota
+  using std::iota;
+
+  namespace ranges {
+    // using std::ranges::iota_result;
+    // using std::ranges::iota;
+  } // namespace ranges
+
+  // [numeric.ops.gcd], greatest common divisor
+  using std::gcd;
+
+  // [numeric.ops.lcm], least common multiple
+  using std::lcm;
+
+  // [numeric.ops.midpoint], midpoint
+  using std::midpoint;
+} // namespace std
+
+// optional.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [optional.optional], class template optional
+  using std::optional;
+
+  // [optional.nullopt], no-value state indicator
+  using std::nullopt;
+  using std::nullopt_t;
+
+  // [optional.bad.access], class bad_optional_access
+  using std::bad_optional_access;
+
+  // [optional.relops], relational operators
+  using std::operator==;
+  using std::operator!=;
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  // [optional.specalg], specialized algorithms
+  using std::swap;
+
+  using std::make_optional;
+
+  // [optional.hash], hash support
+  using std::hash;
+} // namespace std
+
+// ostream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::basic_ostream;
+
+  using std::ostream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wostream;
+#  endif
+
+  using std::endl;
+  using std::ends;
+  using std::flush;
+
+#  if 0
+  using std::emit_on_flush;
+  using std::flush_emit;
+  using std::noemit_on_flush;
+#  endif
+  using std::operator<<;
+
+#  if 0
+  // [ostream.formatted.print], print functions
+  using std::print;
+  using std::println;
+
+  using std::vprint_nonunicode;
+  using std::vprint_unicode;
+#  endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// print.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if _LIBCPP_STD_VER >= 23
+  // [print.fun], print functions
+  using std::print;
+  using std::println;
+
+  using std::vprint_nonunicode;
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  using std::vprint_unicode;
+#  endif // _LIBCPP_HAS_NO_UNICODE
+#endif   // _LIBCPP_STD_VER >= 23
+} // namespace std
+
+// queue.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [queue], class template queue
+  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::swap;
+  using std::uses_allocator;
+
+  // [priority.queue], class template priority_queue
+  using std::priority_queue;
+} // namespace std
+
+// random.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [rand.req.urng], uniform random bit generator requirements
+  using std::uniform_random_bit_generator;
+
+  // [rand.eng.lcong], class template linear_congruential_engine
+  using std::linear_congruential_engine;
+
+  // [rand.eng.mers], class template mersenne_twister_engine
+  using std::mersenne_twister_engine;
+
+  // [rand.eng.sub], class template subtract_with_carry_engine
+  using std::subtract_with_carry_engine;
+
+  // [rand.adapt.disc], class template discard_block_engine
+  using std::discard_block_engine;
+
+  // [rand.adapt.ibits], class template independent_bits_engine
+  using std::independent_bits_engine;
+
+  // [rand.adapt.shuf], class template shuffle_order_engine
+  using std::shuffle_order_engine;
+
+  // [rand.predef], engines and engine adaptors with predefined parameters
+  using std::knuth_b;
+  using std::minstd_rand;
+  using std::minstd_rand0;
+  using std::mt19937;
+  using std::mt19937_64;
+  using std::ranlux24;
+  using std::ranlux24_base;
+  using std::ranlux48;
+  using std::ranlux48_base;
+
+  using std::default_random_engine;
+
+#ifndef _LIBCPP_HAS_NO_RANDOM_DEVICE
+  // [rand.device], class random_device
+  using std::random_device;
+#endif
+
+  // [rand.util.seedseq], class seed_seq
+  using std::seed_seq;
+
+  // [rand.util.canonical], function template generate_canonical
+  using std::generate_canonical;
+
+  // [rand.dist.uni.int], class template uniform_int_distribution
+  using std::uniform_int_distribution;
+
+  // [rand.dist.uni.real], class template uniform_real_distribution
+  using std::uniform_real_distribution;
+
+  // [rand.dist.bern.bernoulli], class bernoulli_distribution
+  using std::bernoulli_distribution;
+
+  // [rand.dist.bern.bin], class template binomial_distribution
+  using std::binomial_distribution;
+
+  // [rand.dist.bern.geo], class template geometric_distribution
+  using std::geometric_distribution;
+
+  // [rand.dist.bern.negbin], class template negative_binomial_distribution
+  using std::negative_binomial_distribution;
+
+  // [rand.dist.pois.poisson], class template poisson_distribution
+  using std::poisson_distribution;
+
+  // [rand.dist.pois.exp], class template exponential_distribution
+  using std::exponential_distribution;
+
+  // [rand.dist.pois.gamma], class template gamma_distribution
+  using std::gamma_distribution;
+
+  // [rand.dist.pois.weibull], class template weibull_distribution
+  using std::weibull_distribution;
+
+  // [rand.dist.pois.extreme], class template extreme_value_distribution
+  using std::extreme_value_distribution;
+
+  // [rand.dist.norm.normal], class template normal_distribution
+  using std::normal_distribution;
+
+  // [rand.dist.norm.lognormal], class template lognormal_distribution
+  using std::lognormal_distribution;
+
+  // [rand.dist.norm.chisq], class template chi_squared_distribution
+  using std::chi_squared_distribution;
+
+  // [rand.dist.norm.cauchy], class template cauchy_distribution
+  using std::cauchy_distribution;
+
+  // [rand.dist.norm.f], class template fisher_f_distribution
+  using std::fisher_f_distribution;
+
+  // [rand.dist.norm.t], class template student_t_distribution
+  using std::student_t_distribution;
+
+  // [rand.dist.samp.discrete], class template discrete_distribution
+  using std::discrete_distribution;
+
+  // [rand.dist.samp.pconst], class template piecewise_constant_distribution
+  using std::piecewise_constant_distribution;
+
+  // [rand.dist.samp.plinear], class template piecewise_linear_distribution
+  using std::piecewise_linear_distribution;
+} // namespace std
+
+// ranges.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  namespace ranges {
+    inline namespace __cpo {
+      // [range.access], range access
+      using std::ranges::__cpo::begin;
+      using std::ranges::__cpo::cbegin;
+      using std::ranges::__cpo::cend;
+      using std::ranges::__cpo::crbegin;
+      using std::ranges::__cpo::crend;
+      using std::ranges::__cpo::end;
+      using std::ranges::__cpo::rbegin;
+      using std::ranges::__cpo::rend;
+
+      using std::ranges::__cpo::cdata;
+      using std::ranges::__cpo::data;
+      using std::ranges::__cpo::empty;
+      using std::ranges::__cpo::size;
+      using std::ranges::__cpo::ssize;
+    } // namespace __cpo
+
+    // [range.range], ranges
+    using std::ranges::range;
+
+    using std::ranges::enable_borrowed_range;
+
+    using std::ranges::borrowed_range;
+
+    // using std::ranges::const_iterator_t;
+    // using std::ranges::const_sentinel_t;
+    using std::ranges::iterator_t;
+    // using std::ranges::range_const_reference_t;
+    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;
+
+    // [range.sized], sized ranges
+    using std::ranges::disable_sized_range;
+    using std::ranges::sized_range;
+
+    // [range.view], views
+    using std::ranges::enable_view;
+    using std::ranges::view;
+    using std::ranges::view_base;
+
+    // [range.refinements], other range refinements
+    using std::ranges::bidirectional_range;
+    using std::ranges::common_range;
+    // using std::ranges::constant_range;
+    using std::ranges::contiguous_range;
+    using std::ranges::forward_range;
+    using std::ranges::input_range;
+    using std::ranges::output_range;
+    using std::ranges::random_access_range;
+    using std::ranges::viewable_range;
+
+    // [view.interface], class template view_­interface
+    using std::ranges::view_interface;
+
+    // [range.subrange], sub-ranges
+    using std::ranges::subrange;
+    using std::ranges::subrange_kind;
+
+    using std::ranges::get;
+  } // namespace ranges
+
+  using std::ranges::get;
+
+  namespace ranges {
+
+    // [range.dangling], dangling iterator handling
+    using std::ranges::dangling;
+
+    // [range.elementsof], class template elements_­of
+    // using std::ranges::elements_of;
+
+    using std::ranges::borrowed_iterator_t;
+
+    using std::ranges::borrowed_subrange_t;
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.utility.conv], range conversions
+    using std::ranges::to;
+#endif
+
+    // [range.empty], empty view
+    using std::ranges::empty_view;
+
+    namespace views {
+      using std::ranges::views::empty;
+    }
+
+    // [range.single], single view
+    using std::ranges::single_view;
+
+    namespace views {
+      using std::ranges::views::single;
+    } // namespace views
+
+    // [range.iota], iota view
+    using std::ranges::iota_view;
+
+    namespace views {
+      using std::ranges::views::iota;
+    } // namespace views
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.repeat], repeat view
+    using std::ranges::repeat_view;
+
+    namespace views {
+      using std::ranges::views::repeat;
+    } // namespace views
+#endif // _LIBCPP_STD_VER >= 23
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+    // [range.istream], istream view
+    using std::ranges::basic_istream_view;
+    using std::ranges::istream_view;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    using std::ranges::wistream_view;
+#  endif
+
+    namespace views {
+      using std::ranges::views::istream;
+    }
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+
+    // [range.adaptor.object], range adaptor objects
+    // using std::ranges::range_adaptor_closure;
+
+    // [range.all], all view
+    namespace views {
+      using std::ranges::views::all;
+      using std::ranges::views::all_t;
+    } // namespace views
+
+    // [range.ref.view], ref view
+    using std::ranges::ref_view;
+
+    // [range.owning.view], owning view
+    using std::ranges::owning_view;
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.as.rvalue], as rvalue view
+    using std::ranges::as_rvalue_view;
+
+    namespace views {
+      using std::ranges::views::as_rvalue;
+    } // namespace views
+#endif // _LIBCPP_STD_VER >= 23
+
+    // [range.filter], filter view
+    using std::ranges::filter_view;
+
+    namespace views {
+      using std::ranges::views::filter;
+    } // namespace views
+
+    // [range.transform], transform view
+    using std::ranges::transform_view;
+
+    namespace views {
+      using std::ranges::views::transform;
+    } // namespace views
+
+    // [range.take], take view
+    using std::ranges::take_view;
+
+    namespace views {
+      using std::ranges::views::take;
+    } // namespace views
+
+    // [range.take.while], take while view
+    using std::ranges::take_while_view;
+
+    namespace views {
+      using std::ranges::views::take_while;
+    } // namespace views
+
+    // [range.drop], drop view
+    using std::ranges::drop_view;
+
+    namespace views {
+      using std::ranges::views::drop;
+    } // namespace views
+
+    // [range.drop.while], drop while view
+    using std::ranges::drop_while_view;
+
+    namespace views {
+      using std::ranges::views::drop_while;
+    } // namespace views
+
+#ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+    using std::ranges::join_view;
+
+    namespace views {
+      using std::ranges::views::join;
+    } // namespace views
+#endif // _LIBCPP_ENABLE_EXPERIMENTAL
+#if 0
+    using std::ranges::join_with_view;
+
+    namespace views {
+      using std::ranges::views::join_with;
+    } // namespace views
+#endif
+    using std::ranges::lazy_split_view;
+
+    // [range.split], split view
+    using std::ranges::split_view;
+
+    namespace views {
+      using std::ranges::views::lazy_split;
+      using std::ranges::views::split;
+    } // namespace views
+
+    // [range.counted], counted view
+    namespace views {
+      using std::ranges::views::counted;
+    } // namespace views
+
+    // [range.common], common view
+    using std::ranges::common_view;
+
+    namespace views {
+      using std::ranges::views::common;
+    } // namespace views
+
+    // [range.reverse], reverse view
+    using std::ranges::reverse_view;
+
+    namespace views {
+      using std::ranges::views::reverse;
+    } // namespace views
+
+    // [range.as.const], as const view
+#if 0
+    using std::ranges::as_const_view;
+
+    namespace views {
+      using std::ranges::views::as_const;
+    } // namespace views
+#endif
+    // [range.elements], elements view
+    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;
+    } // namespace views
+
+#if _LIBCPP_STD_VER >= 23
+    // [range.zip], zip view
+    using std::ranges::zip_view;
+
+    namespace views {
+      using std::ranges::views::zip;
+    } // namespace views
+#endif // _LIBCPP_STD_VER >= 23
+
+#if 0
+    // [range.zip.transform], zip transform view
+    using std::ranges::zip_transform_view;
+
+    namespace views {
+      using std::ranges::views::zip_transform;
+    }
+
+    using std::ranges::adjacent_view;
+
+    namespace views {
+      using std::ranges::views::adjacent;
+      using std::ranges::views::pairwise;
+    } // namespace views
+
+    using std::ranges::adjacent_transform_view;
+
+    namespace views {
+      using std::ranges::views::adjacent_transform;
+      using std::ranges::views::pairwise_transform;
+    } // namespace views
+
+    using std::ranges::chunk_view;
+
+    using std::ranges::chunk_view<V>;
+
+    namespace views {
+      using std::ranges::views::chunk;
+    }
+
+    using std::ranges::slide_view;
+
+    namespace views {
+      using std::ranges::views::slide;
+    }
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+#if _LIBCPP_VERSION >= 180000
+    // [range.chunk.by], chunk by view
+    using std::ranges::chunk_by_view;
+
+    namespace views {
+      using std::ranges::views::chunk_by;
+    }
+#endif
+#endif // _LIBCPP_STD_VER >= 23
+
+#if 0
+    // [range.stride], stride view
+    using std::ranges::stride_view;
+
+    namespace views {
+      using std::ranges::views::stride;
+    }
+
+    using std::ranges::cartesian_product_view;
+
+    namespace views {
+      using std::ranges::views::cartesian_product;
+    }
+#endif
+  } // namespace ranges
+
+  namespace views = ranges::views;
+
+  using std::tuple_element;
+  using std::tuple_size;
+
+#if _LIBCPP_STD_VER >= 23
+  using std::from_range;
+  using std::from_range_t;
+#endif // _LIBCPP_STD_VER >= 23
+} // namespace std
+
+// ratio.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [ratio.ratio], class template ratio
+  using std::ratio;
+
+  // [ratio.arithmetic], ratio arithmetic
+  using std::ratio_add;
+  using std::ratio_divide;
+  using std::ratio_multiply;
+  using std::ratio_subtract;
+
+  // [ratio.comparison], ratio comparison
+  using std::ratio_equal;
+  using std::ratio_greater;
+  using std::ratio_greater_equal;
+  using std::ratio_less;
+  using std::ratio_less_equal;
+  using std::ratio_not_equal;
+
+  using std::ratio_equal_v;
+  using std::ratio_greater_equal_v;
+  using std::ratio_greater_v;
+  using std::ratio_less_equal_v;
+  using std::ratio_less_v;
+  using std::ratio_not_equal_v;
+
+  // [ratio.si], convenience SI typedefs
+  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::tera;
+
+  // These are not supported by libc++, due to the range of intmax_t
+  // using std::yocto;
+  // using std::yotta;
+  // using std::zepto;
+  // using std::zetta
+} // namespace std
+
+// rcu.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+#  if _LIBCPP_STD_VER >= 23
+  // 2.2.3, class template rcu_obj_base using std::rcu_obj_base;
+  // 2.2.4, class rcu_domain
+  using std::rcu_domain;
+  using std::rcu_default_domain();
+  using std::rcu_barrier;
+  using std::rcu_retire;
+  using std::rcu_synchronize;
+#  endif // _LIBCPP_STD_VER >= 23
+#endif
+} // namespace std
+
+// regex.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  // [re.const], regex constants
+  namespace regex_constants {
+    using std::regex_constants::error_type;
+    using std::regex_constants::match_flag_type;
+    using std::regex_constants::syntax_option_type;
+
+    // regex_constants is a bitmask type.
+    // [bitmask.types] specified operators
+    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~;
+
+  } // namespace regex_constants
+
+  // [re.badexp], class regex_error
+  using std::regex_error;
+
+  // [re.traits], class template regex_traits
+  using std::regex_traits;
+
+  // [re.regex], class template basic_regex
+  using std::basic_regex;
+
+  using std::regex;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wregex;
+#  endif
+
+  // [re.regex.swap], basic_regex swap
+  using std::swap;
+
+  // [re.submatch], class template sub_match
+  using std::sub_match;
+
+  using std::csub_match;
+  using std::ssub_match;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wcsub_match;
+  using std::wssub_match;
+#  endif
+
+  // [re.submatch.op], sub_match non-member operators
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::operator<<;
+
+  // [re.results], class template match_results
+  using std::match_results;
+
+  using std::cmatch;
+  using std::smatch;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wcmatch;
+  using std::wsmatch;
+#  endif
+
+  // match_results comparisons
+
+  // [re.results.swap], match_results swap
+
+  // [re.alg.match], function template regex_match
+  using std::regex_match;
+
+  // [re.alg.search], function template regex_search
+  using std::regex_search;
+
+  // [re.alg.replace], function template regex_replace
+  using std::regex_replace;
+
+  // [re.regiter], class template regex_iterator
+  using std::regex_iterator;
+
+  using std::cregex_iterator;
+  using std::sregex_iterator;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wcregex_iterator;
+  using std::wsregex_iterator;
+#  endif
+
+  // [re.tokiter], class template regex_token_iterator
+  using std::regex_token_iterator;
+
+  using std::cregex_token_iterator;
+  using std::sregex_token_iterator;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wcregex_token_iterator;
+  using std::wsregex_token_iterator;
+#  endif
+
+  namespace pmr {
+    using std::pmr::match_results;
+
+    using std::pmr::cmatch;
+    using std::pmr::smatch;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    using std::pmr::wcmatch;
+    using std::pmr::wsmatch;
+#  endif
+  }    // namespace pmr
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// scoped_allocator.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // class template scoped_allocator_adaptor
+  using std::scoped_allocator_adaptor;
+
+  // [scoped.adaptor.operators], scoped allocator operators
+  using std::operator==;
+
+} // namespace std
+
+// semaphore.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  // [thread.sema.cnt], class template counting_semaphore
+  using std::counting_semaphore;
+
+  using std::binary_semaphore;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// set.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [set], class template set
+  using std::set;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::swap;
+
+  // [set.erasure], erasure for set
+  using std::erase_if;
+
+  // [multiset], class template multiset
+  using std::multiset;
+
+  namespace pmr {
+    using std::pmr::multiset;
+    using std::pmr::set;
+  } // namespace pmr
+} // namespace std
+
+// shared_mutex.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  // [thread.sharedmutex.class], class shared_­mutex
+  using std::shared_mutex;
+  // [thread.sharedtimedmutex.class], class shared_­timed_­mutex
+  using std::shared_timed_mutex;
+  // [thread.lock.shared], class template shared_­lock
+  using std::shared_lock;
+  using std::swap;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// source_location.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::source_location;
+} // namespace std
+
+// span.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // constants
+  using std::dynamic_extent;
+
+  // [views.span], class template span
+  using std::span;
+
+  namespace ranges {
+    using std::ranges::enable_borrowed_range;
+    using std::ranges::enable_view;
+  } // namespace ranges
+
+  // [span.objectrep], views of object representation
+  using std::as_bytes;
+
+  using std::as_writable_bytes;
+} // namespace std
+
+// spanstream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+  using std::basic_spanbuf;
+
+  using std::swap;
+
+  using std::spanbuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wspanbuf;
+#  endif
+
+  using std::basic_ispanstream;
+
+  using std::ispanstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wispanstream;
+#  endif
+
+  using std::basic_ospanstream;
+
+  using std::ospanstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wospanstream;
+#  endif
+
+  using std::basic_spanstream;
+
+  using std::spanstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wspanstream;
+#  endif
+#endif
+} // namespace std
+
+// sstream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::basic_stringbuf;
+
+  using std::swap;
+
+  using std::stringbuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstringbuf;
+#  endif
+
+  using std::basic_istringstream;
+
+  using std::istringstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wistringstream;
+#  endif
+
+  using std::basic_ostringstream;
+
+  using std::ostringstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wostringstream;
+#  endif
+
+  using std::basic_stringstream;
+
+  using std::stringstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstringstream;
+#  endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// stack.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [stack], class template stack
+  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;
+} // namespace std
+
+// stacktrace.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+  // [stacktrace.entry], class stacktrace_­entry
+  using std::stacktrace_entry;
+
+  // [stacktrace.basic], class template basic_­stacktrace
+  using std::basic_stacktrace;
+
+  // basic_­stacktrace typedef-names
+  using std::stacktrace;
+
+  // [stacktrace.basic.nonmem], non-member functions
+  using std::swap;
+
+  using std::to_string;
+
+  using std::operator<<;
+
+  namespace pmr {
+    using std::pmr::stacktrace;
+  }
+
+  // [stacktrace.basic.hash], hash support
+  using std::hash;
+#endif
+} // namespace std
+
+// stdexcept.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+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;
+} // namespace std
+
+// stdfloat.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if defined(__STDCPP_FLOAT16_T__)
+  using std::float16_t;
+#endif
+#if defined(__STDCPP_FLOAT32_T__)
+  using std::float32_t;
+#endif
+#if defined(__STDCPP_FLOAT64_T__)
+  using std::float64_t;
+#endif
+#if defined(__STDCPP_FLOAT128_T__)
+  using std::float128_t;
+#endif
+#if defined(__STDCPP_BFLOAT16_T__)
+  using std::bfloat16_t;
+#endif
+} // namespace std
+
+// stop_token.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+  // [stoptoken], class stop_­token
+  using std::stop_token;
+
+  // [stopsource], class stop_­source
+  using std::stop_source;
+
+  // no-shared-stop-state indicator
+  using std::nostopstate;
+  using std::nostopstate_t;
+
+  // [stopcallback], class template stop_­callback
+  using std::stop_callback;
+#  endif // _LIBCPP_ENABLE_EXPERIMENTAL
+#endif   // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// streambuf.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::basic_streambuf;
+  using std::streambuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstreambuf;
+#  endif
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// string.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [char.traits], character traits
+  using std::char_traits;
+
+  // [basic.string], basic_string
+  using std::basic_string;
+
+  using std::operator+;
+  using std::operator==;
+  using std::operator<=>;
+
+  // [string.special], swap
+  using std::swap;
+
+  // [string.io], inserters and extractors
+  using std::operator>>;
+  using std::operator<<;
+  using std::getline;
+
+  // [string.erasure], erasure
+  using std::erase;
+  using std::erase_if;
+
+  // basic_string typedef-names
+  using std::string;
+  using std::u16string;
+  using std::u32string;
+  using std::u8string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstring;
+#endif
+
+  // [string.conversions], numeric conversions
+  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::to_string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::to_wstring;
+#endif
+
+  namespace pmr {
+    using std::pmr::basic_string;
+    using std::pmr::string;
+    using std::pmr::u16string;
+    using std::pmr::u32string;
+    using std::pmr::u8string;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    using std::pmr::wstring;
+#endif
+  } // namespace pmr
+
+  // [basic.string.hash], hash support
+  using std::hash;
+
+  // TODO MODULES is this a bug?
+#if _LIBCPP_STD_VER >= 23
+  using std::operator""s;
+#else
+  inline namespace literals {
+    inline namespace string_literals {
+      // [basic.string.literals], suffix for basic_string literals
+      using std::literals::string_literals::operator""s;
+    } // namespace string_literals
+  }   // namespace literals
+#endif
+} // namespace std
+
+// string_view.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [string.view.template], class template basic_string_view
+  using std::basic_string_view;
+
+  namespace ranges {
+    using std::ranges::enable_borrowed_range;
+    using std::ranges::enable_view;
+  } // namespace ranges
+
+  // [string.view.comparison], non-member comparison functions
+  using std::operator==;
+  using std::operator<=>;
+
+  // [string.view.io], inserters and extractors
+  using std::operator<<;
+
+  // basic_string_view typedef-names
+  using std::string_view;
+  using std::u16string_view;
+  using std::u32string_view;
+  using std::u8string_view;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wstring_view;
+#endif
+
+  // [string.view.hash], hash support
+  using std::hash;
+
+  inline namespace literals {
+    inline namespace string_view_literals {
+      // [string.view.literals], suffix for basic_string_view literals
+      using std::literals::string_view_literals::operator""sv;
+    } // namespace string_view_literals
+  }   // namespace literals
+} // namespace std
+
+// strstream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::istrstream;
+  using std::ostrstream;
+  using std::strstream;
+  using std::strstreambuf;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+} // namespace std
+
+// syncstream.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifdef _LIBCPP_HAS_YES_SYNCSTREAM
+
+export namespace std {
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
+  using std::basic_syncbuf;
+
+  // [syncstream.syncbuf.special], specialized algorithms
+  using std::swap;
+
+  using std::syncbuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wsyncbuf;
+#  endif
+  using std::basic_osyncstream;
+
+  using std::osyncstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  using std::wosyncstream;
+#  endif
+#endif // !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
+} // namespace std
+
+#endif
+
+// system_error.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::error_category;
+  using std::generic_category;
+  using std::system_category;
+
+  using std::error_code;
+  using std::error_condition;
+  using std::system_error;
+
+  using std::is_error_code_enum;
+  using std::is_error_condition_enum;
+
+  using std::errc;
+
+  // [syserr.errcode.nonmembers], non-member functions
+  using std::make_error_code;
+
+  using std::operator<<;
+
+  // [syserr.errcondition.nonmembers], non-member functions
+  using std::make_error_condition;
+
+  // [syserr.compare], comparison operator functions
+  using std::operator==;
+  using std::operator<=>;
+
+  // [syserr.hash], hash support
+  using std::hash;
+
+  // [syserr], system error support
+  using std::is_error_code_enum_v;
+  using std::is_error_condition_enum_v;
+} // namespace std
+
+// text_encoding.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#if 0
+#  if _LIBCPP_STD_VER >= 23
+  using std::text_encoding;
+
+  // hash support
+  using std::hash;
+#  endif // _LIBCPP_STD_VER >= 23
+#endif
+} // namespace std
+
+// thread.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  // [thread.thread.class], class thread
+  using std::thread;
+
+  using std::swap;
+
+  // [thread.jthread.class], class jthread
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+  using std::jthread;
+#  endif
+
+  // [thread.thread.this], namespace this_thread
+  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;
+  } // namespace this_thread
+
+  // [thread.thread.id]
+  using std::operator==;
+  using std::operator<=>;
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  using std::operator<<;
+#  endif // _LIBCPP_HAS_NO_LOCALIZATION
+
+#  if _LIBCPP_STD_VER >= 23
+  using std::formatter;
+#  endif
+
+  using std::hash;
+#endif // _LIBCPP_HAS_NO_THREADS
+} // namespace std
+
+// tuple.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [tuple.tuple], class template tuple
+  using std::tuple;
+
+  // [tuple.like], concept tuple-like
+
+#if _LIBCPP_STD_VER >= 23
+  // [tuple.common.ref], common_reference related specializations
+  using std::basic_common_reference;
+  using std::common_type;
+#endif
+
+  // [tuple.creation], tuple creation functions
+  using std::ignore;
+
+  using std::forward_as_tuple;
+  using std::make_tuple;
+  using std::tie;
+  using std::tuple_cat;
+
+  // [tuple.apply], calling a function with a tuple of arguments
+  using std::apply;
+
+  using std::make_from_tuple;
+
+  // [tuple.helper], tuple helper classes
+  using std::tuple_element;
+  using std::tuple_size;
+
+  // [tuple.elem], element access
+  using std::get;
+  using std::tuple_element_t;
+
+  // [tuple.rel], relational operators
+  using std::operator==;
+  using std::operator<=>;
+
+  // [tuple.traits], allocator-related traits
+  using std::uses_allocator;
+
+  // [tuple.special], specialized algorithms
+  using std::swap;
+
+  // [tuple.helper], tuple helper classes
+  using std::tuple_size_v;
+} // namespace std
+
+// type_traits.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [meta.help], helper class
+  using std::integral_constant;
+
+  using std::bool_constant;
+  using std::false_type;
+  using std::true_type;
+
+  // [meta.unary.cat], primary type categories
+  using std::is_array;
+  using std::is_class;
+  using std::is_enum;
+  using std::is_floating_point;
+  using std::is_function;
+  using std::is_integral;
+  using std::is_lvalue_reference;
+  using std::is_member_function_pointer;
+  using std::is_member_object_pointer;
+  using std::is_null_pointer;
+  using std::is_pointer;
+  using std::is_rvalue_reference;
+  using std::is_union;
+  using std::is_void;
+
+  // [meta.unary.comp], composite type categories
+  using std::is_arithmetic;
+  using std::is_compound;
+  using std::is_fundamental;
+  using std::is_member_pointer;
+  using std::is_object;
+  using std::is_reference;
+  using std::is_scalar;
+
+  // [meta.unary.prop], type properties
+  using std::is_abstract;
+  using std::is_aggregate;
+  using std::is_const;
+  using std::is_empty;
+  using std::is_final;
+  using std::is_polymorphic;
+  using std::is_standard_layout;
+  using std::is_trivial;
+  using std::is_trivially_copyable;
+  using std::is_volatile;
+
+  using std::is_bounded_array;
+#if _LIBCPP_STD_VER >= 23
+  using std::is_scoped_enum;
+#endif
+  using std::is_signed;
+  using std::is_unbounded_array;
+  using std::is_unsigned;
+
+  using std::is_constructible;
+  using std::is_copy_constructible;
+  using std::is_default_constructible;
+  using std::is_move_constructible;
+
+  using std::is_assignable;
+  using std::is_copy_assignable;
+  using std::is_move_assignable;
+
+  using std::is_swappable;
+  using std::is_swappable_with;
+
+  using std::is_destructible;
+
+  using std::is_trivially_constructible;
+  using std::is_trivially_copy_constructible;
+  using std::is_trivially_default_constructible;
+  using std::is_trivially_move_constructible;
+
+  using std::is_trivially_assignable;
+  using std::is_trivially_copy_assignable;
+  using std::is_trivially_destructible;
+  using std::is_trivially_move_assignable;
+
+  using std::is_nothrow_constructible;
+  using std::is_nothrow_copy_constructible;
+  using std::is_nothrow_default_constructible;
+  using std::is_nothrow_move_constructible;
+
+  using std::is_nothrow_assignable;
+  using std::is_nothrow_copy_assignable;
+  using std::is_nothrow_move_assignable;
+
+  using std::is_nothrow_swappable;
+  using std::is_nothrow_swappable_with;
+
+  using std::is_nothrow_destructible;
+
+  //  using std::is_implicit_lifetime;
+
+  using std::has_virtual_destructor;
+
+  using std::has_unique_object_representations;
+
+  // using std::reference_constructs_from_temporary;
+  // using std::reference_converts_from_temporary;
+
+  // [meta.unary.prop.query], type property queries
+  using std::alignment_of;
+  using std::extent;
+  using std::rank;
+
+  // [meta.rel], type relations
+  using std::is_base_of;
+  using std::is_convertible;
+  // using std::is_layout_compatible;
+  using std::is_nothrow_convertible;
+  // using std::is_pointer_interconvertible_base_of;
+  using std::is_same;
+
+  using std::is_invocable;
+  using std::is_invocable_r;
+
+  using std::is_nothrow_invocable;
+  using std::is_nothrow_invocable_r;
+
+  // [meta.trans.cv], const-volatile modifications
+  using std::add_const;
+  using std::add_cv;
+  using std::add_volatile;
+  using std::remove_const;
+  using std::remove_cv;
+  using std::remove_volatile;
+
+  using std::add_const_t;
+  using std::add_cv_t;
+  using std::add_volatile_t;
+  using std::remove_const_t;
+  using std::remove_cv_t;
+  using std::remove_volatile_t;
+
+  // [meta.trans.ref], reference modifications
+  using std::add_lvalue_reference;
+  using std::add_rvalue_reference;
+  using std::remove_reference;
+
+  using std::add_lvalue_reference_t;
+  using std::add_rvalue_reference_t;
+  using std::remove_reference_t;
+
+  // [meta.trans.sign], sign modifications
+  using std::make_signed;
+  using std::make_unsigned;
+
+  using std::make_signed_t;
+  using std::make_unsigned_t;
+
+  // [meta.trans.arr], array modifications
+  using std::remove_all_extents;
+  using std::remove_extent;
+
+  using std::remove_all_extents_t;
+  using std::remove_extent_t;
+
+  // [meta.trans.ptr], pointer modifications
+  using std::add_pointer;
+  using std::remove_pointer;
+
+  using std::add_pointer_t;
+  using std::remove_pointer_t;
+
+  // [meta.trans.other], other transformations
+  using std::basic_common_reference;
+  using std::common_reference;
+  using std::common_type;
+  using std::conditional;
+  using std::decay;
+  using std::enable_if;
+  using std::invoke_result;
+  using std::remove_cvref;
+  using std::type_identity;
+  using std::underlying_type;
+  using std::unwrap_ref_decay;
+  using std::unwrap_reference;
+
+  using std::common_reference_t;
+  using std::common_type_t;
+  using std::conditional_t;
+  using std::decay_t;
+  using std::enable_if_t;
+  using std::invoke_result_t;
+  using std::remove_cvref_t;
+  using std::type_identity_t;
+  using std::underlying_type_t;
+  using std::unwrap_ref_decay_t;
+  using std::unwrap_reference_t;
+  using std::void_t;
+
+  // [meta.logical], logical operator traits
+  using std::conjunction;
+  using std::disjunction;
+  using std::negation;
+
+  // [meta.unary.cat], primary type categories
+  using std::is_array_v;
+  using std::is_class_v;
+  using std::is_enum_v;
+  using std::is_floating_point_v;
+  using std::is_function_v;
+  using std::is_integral_v;
+  using std::is_lvalue_reference_v;
+  using std::is_member_function_pointer_v;
+  using std::is_member_object_pointer_v;
+  using std::is_null_pointer_v;
+  using std::is_pointer_v;
+  using std::is_rvalue_reference_v;
+  using std::is_union_v;
+  using std::is_void_v;
+
+  // [meta.unary.comp], composite type categories
+  using std::is_arithmetic_v;
+  using std::is_compound_v;
+  using std::is_fundamental_v;
+  using std::is_member_pointer_v;
+  using std::is_object_v;
+  using std::is_reference_v;
+  using std::is_scalar_v;
+
+  // [meta.unary.prop], type properties
+  using std::has_unique_object_representations_v;
+  using std::has_virtual_destructor_v;
+  using std::is_abstract_v;
+  using std::is_aggregate_v;
+  using std::is_assignable_v;
+  using std::is_bounded_array_v;
+  using std::is_const_v;
+  using std::is_constructible_v;
+  using std::is_copy_assignable_v;
+  using std::is_copy_constructible_v;
+  using std::is_default_constructible_v;
+  using std::is_destructible_v;
+  using std::is_empty_v;
+  using std::is_final_v;
+  // using std::is_implicit_lifetime_v;
+  using std::is_move_assignable_v;
+  using std::is_move_constructible_v;
+  using std::is_nothrow_assignable_v;
+  using std::is_nothrow_constructible_v;
+  using std::is_nothrow_copy_assignable_v;
+  using std::is_nothrow_copy_constructible_v;
+  using std::is_nothrow_default_constructible_v;
+  using std::is_nothrow_destructible_v;
+  using std::is_nothrow_move_assignable_v;
+  using std::is_nothrow_move_constructible_v;
+  using std::is_nothrow_swappable_v;
+  using std::is_nothrow_swappable_with_v;
+  using std::is_polymorphic_v;
+#if _LIBCPP_STD_VER >= 23
+  using std::is_scoped_enum_v;
+#endif
+  using std::is_signed_v;
+  using std::is_standard_layout_v;
+  using std::is_swappable_v;
+  using std::is_swappable_with_v;
+  using std::is_trivial_v;
+  using std::is_trivially_assignable_v;
+  using std::is_trivially_constructible_v;
+  using std::is_trivially_copy_assignable_v;
+  using std::is_trivially_copy_constructible_v;
+  using std::is_trivially_copyable_v;
+  using std::is_trivially_default_constructible_v;
+  using std::is_trivially_destructible_v;
+  using std::is_trivially_move_assignable_v;
+  using std::is_trivially_move_constructible_v;
+  using std::is_unbounded_array_v;
+  using std::is_unsigned_v;
+  using std::is_volatile_v;
+  // using std::reference_constructs_from_temporary_v;
+  // using std::reference_converts_from_temporary_v;
+
+  // [meta.unary.prop.query], type property queries
+  using std::alignment_of_v;
+  using std::extent_v;
+  using std::rank_v;
+
+  // [meta.rel], type relations
+  using std::is_base_of_v;
+  using std::is_convertible_v;
+  using std::is_invocable_r_v;
+  using std::is_invocable_v;
+  // using std::is_layout_compatible_v;
+  using std::is_nothrow_convertible_v;
+  using std::is_nothrow_invocable_r_v;
+  using std::is_nothrow_invocable_v;
+  // using std::is_pointer_interconvertible_base_of_v;
+  using std::is_same_v;
+
+  // [meta.logical], logical operator traits
+  using std::conjunction_v;
+  using std::disjunction_v;
+  using std::negation_v;
+
+  // [meta.member], member relationships
+  // using std::is_corresponding_member;
+  // using std::is_pointer_interconvertible_with_class;
+
+  // [meta.const.eval], constant evaluation context
+  using std::is_constant_evaluated;
+
+  // [depr.meta.types]
+  using std::aligned_storage;
+  using std::aligned_storage_t;
+  using std::aligned_union;
+  using std::aligned_union_t;
+  using std::is_pod;
+  using std::is_pod_v;
+} // namespace std
+
+// typeindex.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::hash;
+  using std::type_index;
+} // namespace std
+
+// typeinfo.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  using std::bad_cast;
+  using std::bad_typeid;
+  using std::type_info;
+} // namespace std
+
+// unordered_map.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [unord.map], class template unordered_­map
+  using std::unordered_map;
+
+  // [unord.multimap], class template unordered_­multimap
+  using std::unordered_multimap;
+
+  using std::operator==;
+
+  using std::swap;
+
+  // [unord.map.erasure], erasure for unordered_­map
+  using std::erase_if;
+
+  namespace pmr {
+    using std::pmr::unordered_map;
+    using std::pmr::unordered_multimap;
+  } // namespace pmr
+} // namespace std
+
+// unordered_set.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [unord.set], class template unordered_­set
+  using std::unordered_set;
+
+  // [unord.multiset], class template unordered_­multiset
+  using std::unordered_multiset;
+
+  using std::operator==;
+
+  using std::swap;
+
+  // [unord.set.erasure], erasure for unordered_­set
+  using std::erase_if;
+
+  namespace pmr {
+    using std::pmr::unordered_multiset;
+    using std::pmr::unordered_set;
+  } // namespace pmr
+} // namespace std
+
+// utility.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [utility.swap], swap
+  using std::swap;
+
+  // [utility.exchange], exchange
+  using std::exchange;
+
+  // [forward], forward/move
+  using std::forward;
+#if _LIBCPP_STD_VER >= 23
+  using std::forward_like;
+#endif
+  using std::move;
+  using std::move_if_noexcept;
+
+  // [utility.as.const], as_const
+  using std::as_const;
+
+  // [declval], declval
+  using std::declval;
+
+  // [utility.intcmp], integer comparison functions
+  using std::cmp_equal;
+  using std::cmp_not_equal;
+
+  using std::cmp_greater;
+  using std::cmp_greater_equal;
+  using std::cmp_less;
+  using std::cmp_less_equal;
+
+  using std::in_range;
+
+#if _LIBCPP_STD_VER >= 23
+  // [utility.underlying], to_underlying
+  using std::to_underlying;
+
+  // [utility.unreachable], unreachable
+  using std::unreachable;
+#endif // _LIBCPP_STD_VER >= 23
+
+  // [intseq], compile-time integer sequences
+  using std::index_sequence;
+  using std::integer_sequence;
+
+  using std::make_index_sequence;
+  using std::make_integer_sequence;
+
+  using std::index_sequence_for;
+
+  // [pairs], class template pair
+  using std::pair;
+
+#if _LIBCPP_STD_VER >= 23
+  using std::basic_common_reference;
+  using std::common_type;
+#endif
+  // [pairs.spec], pair specialized algorithms
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::make_pair;
+
+  // [pair.astuple], tuple-like access to pair
+  using std::tuple_element;
+  using std::tuple_size;
+
+  using std::get;
+
+  // [pair.piecewise], pair piecewise construction
+  using std::piecewise_construct;
+  using std::piecewise_construct_t;
+
+  // in-place construction
+  using std::in_place;
+  using std::in_place_t;
+
+  using std::in_place_type;
+  using std::in_place_type_t;
+
+  using std::in_place_index;
+  using std::in_place_index_t;
+
+  // [depr.relops]
+  namespace rel_ops {
+    using rel_ops::operator!=;
+    using rel_ops::operator>;
+    using rel_ops::operator<=;
+    using rel_ops::operator>=;
+  } // namespace rel_ops
+} // namespace std
+
+// valarray.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+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::valarray;
+
+  using std::swap;
+
+  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::cos;
+  using std::cosh;
+  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;
+
+  using std::begin;
+  using std::end;
+} // namespace std
+
+// variant.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [variant.variant], class template variant
+  using std::variant;
+
+  // [variant.helper], variant helper classes
+  using std::variant_alternative;
+  using std::variant_npos;
+  using std::variant_size;
+  using std::variant_size_v;
+
+  // [variant.get], value access
+  using std::get;
+  using std::get_if;
+  using std::holds_alternative;
+  using std::variant_alternative_t;
+
+  // [variant.relops], relational operators
+  using std::operator==;
+  using std::operator!=;
+  using std::operator<;
+  using std::operator>;
+  using std::operator<=;
+  using std::operator>=;
+  using std::operator<=>;
+
+  // [variant.visit], visitation
+  using std::visit;
+
+  // [variant.monostate], class monostate
+  using std::monostate;
+
+  // [variant.specalg], specialized algorithms
+  using std::swap;
+
+  // [variant.bad.access], class bad_variant_access
+  using std::bad_variant_access;
+
+  // [variant.hash], hash support
+  using std::hash;
+} // namespace std
+
+// vector.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // [vector], class template vector
+  using std::vector;
+
+  using std::operator==;
+  using std::operator<=>;
+
+  using std::swap;
+
+  // [vector.erasure], erasure
+  using std::erase;
+  using std::erase_if;
+
+  namespace pmr {
+    using std::pmr::vector;
+  }
+
+  // hash support
+  using std::hash;
+
+#if _LIBCPP_STD_VER >= 23
+  // [vector.bool.fmt], formatter specialization for vector<bool>
+  using std::formatter;
+#endif
+} // namespace std
+
+// version.inc
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+export namespace std {
+  // This module exports nothing.
+} // namespace std
diff --git a/libbuild2/utility-installed.cxx b/libbuild2/utility-installed.cxx
index decc71d..e23add1 100644
--- a/libbuild2/utility-installed.cxx
+++ b/libbuild2/utility-installed.cxx
@@ -18,6 +18,10 @@ namespace build2
 #ifdef BUILD2_INSTALL_BUILDFILE
   const dir_path build_install_buildfile (BUILD2_INSTALL_BUILDFILE);
 #endif
+
+#ifdef BUILD2_INSTALL_DATA
+  const dir_path build_install_data (BUILD2_INSTALL_DATA);
+#endif
 }
 
 #endif
diff --git a/libbuild2/utility-uninstalled.cxx b/libbuild2/utility-uninstalled.cxx
index 69908f9..f836de6 100644
--- a/libbuild2/utility-uninstalled.cxx
+++ b/libbuild2/utility-uninstalled.cxx
@@ -13,4 +13,10 @@ namespace build2
 #else
   const dir_path build_install_buildfile; // Empty.
 #endif
+
+#ifdef BUILD2_INSTALL_DATA
+  const dir_path build_install_data (BUILD2_INSTALL_DATA);
+#else
+  const dir_path build_install_data; // Empty (during bootstrap).
+#endif
 }
diff --git a/libbuild2/utility.hxx b/libbuild2/utility.hxx
index f37fc54..594808c 100644
--- a/libbuild2/utility.hxx
+++ b/libbuild2/utility.hxx
@@ -185,12 +185,14 @@ namespace build2
   LIBBUILD2_SYMEXPORT extern const string build_version_interface;
 
   // Whether running installed build as well as the library installation
-  // directory (only if installed, empty otherwise) and the exported buildfile
-  // installation directory (only if configured, empty otherwise).
+  // directory (only if installed, empty otherwise), the exported buildfile
+  // installation directory (only if configured, empty otherwise), and data
+  // installation directory (only if installed, src_root otherwise).
   //
   LIBBUILD2_SYMEXPORT extern const bool build_installed;
   LIBBUILD2_SYMEXPORT extern const dir_path build_install_lib; // $install.lib
   LIBBUILD2_SYMEXPORT extern const dir_path build_install_buildfile; // $install.buildfile
+  LIBBUILD2_SYMEXPORT extern const dir_path build_install_data; // $install.data
 
   // --[no-]mtime-check
   //