diff --git a/contrib/llvm-project/libcxx/include/__ranges/views.h b/contrib/llvm-project/libcxx/include/__ranges/views.h
new file mode 100644
index 000000000000..8cc5ba3d2aca
--- /dev/null
+++ b/contrib/llvm-project/libcxx/include/__ranges/views.h
@@ -0,0 +1,35 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_VIEWS
+#define _LIBCPP___RANGES_VIEWS
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+namespace ranges {
+
+namespace views { }
+
+} // namespace ranges
+
+namespace views = ranges::views;
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_VIEWS
diff --git a/contrib/llvm-project/libcxx/include/module.modulemap b/contrib/llvm-project/libcxx/include/module.modulemap
index 749c17f8bc08..9e3643faee09 100644
--- a/contrib/llvm-project/libcxx/include/module.modulemap
+++ b/contrib/llvm-project/libcxx/include/module.modulemap
@@ -1,1091 +1,1092 @@
 // define the module for __config outside of the top level 'std' module
 // since __config may be included from C headers which may create an
 // include cycle.
 module std_config [system] [extern_c] {
   textual header "__config"
   textual header "__config_site"
 }
 
 module std [system] {
   export std_config
   // FIXME: The standard does not require that each of these submodules
   // re-exports its imported modules. We should provide an alternative form of
   // export that issues a warning if a name from the submodule is used, and
   // use that to provide a 'strict mode' for libc++.
 
   // Deprecated C-compatibility headers. These can all be included from within
   // an 'extern "C"' context.
   module depr [extern_c] {
     // <assert.h> provided by C library.
     module ctype_h {
       header "ctype.h"
       export *
     }
     module errno_h {
       header "errno.h"
       export *
     }
     module fenv_h {
       header "fenv.h"
       export *
     }
     // <float.h> provided by compiler or C library.
     module inttypes_h {
       header "inttypes.h"
       export stdint_h
       export *
     }
     // <iso646.h> provided by compiler.
     // <limits.h> provided by compiler or C library.
     module locale_h {
       header "locale.h"
       export *
     }
     module math_h {
       header "math.h"
       export *
     }
     module setjmp_h {
       header "setjmp.h"
       export *
     }
     // FIXME: <stdalign.h> is missing.
     // <signal.h> provided by C library.
     // <stdarg.h> provided by compiler.
     // <stdbool.h> provided by compiler.
     module stddef_h {
       // <stddef.h>'s __need_* macros require textual inclusion.
       textual header "stddef.h"
     }
     module stdint_h {
       header "stdint.h"
       export *
       // FIXME: This module only exists on OS X and for some reason the
       // wildcard above doesn't export it.
       export Darwin.C.stdint
     }
     module stdio_h {
       // <stdio.h>'s __need_* macros require textual inclusion.
       textual header "stdio.h"
       export *
       export Darwin.C.stdio
     }
     module stdlib_h {
       // <stdlib.h>'s __need_* macros require textual inclusion.
       textual header "stdlib.h"
       export *
     }
     module string_h {
       header "string.h"
       export *
     }
     // FIXME: <uchar.h> is missing.
     // <time.h> provided by C library.
     module wchar_h {
       // <wchar.h>'s __need_* macros require textual inclusion.
       textual header "wchar.h"
       export *
     }
     module wctype_h {
       header "wctype.h"
       export *
     }
   }
 
   // <complex.h> and <tgmath.h> are not C headers in any real sense, do not
   // allow their use in extern "C" contexts.
   module complex_h {
     header "complex.h"
     export ccomplex
     export *
   }
   module tgmath_h {
     header "tgmath.h"
     export ccomplex
     export cmath
     export *
   }
 
   // C compatibility headers.
   module compat {
     module cassert {
       // <cassert>'s use of NDEBUG requires textual inclusion.
       textual header "cassert"
     }
     module ccomplex {
       header "ccomplex"
       export complex
       export *
     }
     module cctype {
       header "cctype"
       export *
     }
     module cerrno {
       header "cerrno"
       export *
     }
     module cfenv {
       header "cfenv"
       export *
     }
     module cfloat {
       header "cfloat"
       export *
     }
     module cinttypes {
       header "cinttypes"
       export cstdint
       export *
     }
     module ciso646 {
       header "ciso646"
       export *
     }
     module climits {
       header "climits"
       export *
     }
     module clocale {
       header "clocale"
       export *
     }
     module cmath {
       header "cmath"
       export *
     }
     module csetjmp {
       header "csetjmp"
       export *
     }
     module csignal {
       header "csignal"
       export *
     }
     // FIXME: <cstdalign> is missing.
     module cstdarg {
       header "cstdarg"
       export *
     }
     module cstdbool {
       header "cstdbool"
       export *
     }
     module cstddef {
       header "cstddef"
       export *
     }
     module cstdint {
       header "cstdint"
       export depr.stdint_h
       export *
     }
     module cstdio {
       header "cstdio"
       export *
     }
     module cstdlib {
       header "cstdlib"
       export *
     }
     module cstring {
       header "cstring"
       export *
     }
     module ctgmath {
       header "ctgmath"
       export ccomplex
       export cmath
       export *
     }
     module ctime {
       header "ctime"
       export *
     }
     // FIXME: <cuchar> is missing.
     module cwchar {
       header "cwchar"
       export depr.stdio_h
       export *
     }
     module cwctype {
       header "cwctype"
       export *
     }
   }
 
   module algorithm {
     header "algorithm"
     export initializer_list
     export *
 
     module __algorithm {
       module adjacent_find            { private header "__algorithm/adjacent_find.h" }
       module all_of                   { private header "__algorithm/all_of.h" }
       module any_of                   { private header "__algorithm/any_of.h" }
       module binary_search            { private header "__algorithm/binary_search.h" }
       module clamp                    { private header "__algorithm/clamp.h" }
       module comp                     { private header "__algorithm/comp.h" }
       module comp_ref_type            { private header "__algorithm/comp_ref_type.h" }
       module copy                     { private header "__algorithm/copy.h" }
       module copy_backward            { private header "__algorithm/copy_backward.h" }
       module copy_if                  { private header "__algorithm/copy_if.h" }
       module copy_n                   { private header "__algorithm/copy_n.h" }
       module count                    { private header "__algorithm/count.h" }
       module count_if                 { private header "__algorithm/count_if.h" }
       module equal                    { private header "__algorithm/equal.h" }
       module equal_range              { private header "__algorithm/equal_range.h" }
       module fill                     { private header "__algorithm/fill.h" }
       module fill_n                   { private header "__algorithm/fill_n.h" }
       module find                     { private header "__algorithm/find.h" }
       module find_end                 { private header "__algorithm/find_end.h" }
       module find_first_of            { private header "__algorithm/find_first_of.h" }
       module find_if                  { private header "__algorithm/find_if.h" }
       module find_if_not              { private header "__algorithm/find_if_not.h" }
       module for_each                 { private header "__algorithm/for_each.h" }
       module for_each_n               { private header "__algorithm/for_each_n.h" }
       module generate                 { private header "__algorithm/generate.h" }
       module generate_n               { private header "__algorithm/generate_n.h" }
       module half_positive            { private header "__algorithm/half_positive.h" }
       module in_in_out_result         { private header "__algorithm/in_in_out_result.h" }
       module in_in_result             { private header "__algorithm/in_in_result.h" }
       module in_out_result            { private header "__algorithm/in_out_result.h" }
       module includes                 { private header "__algorithm/includes.h" }
       module inplace_merge            { private header "__algorithm/inplace_merge.h" }
       module is_heap                  { private header "__algorithm/is_heap.h" }
       module is_heap_until            { private header "__algorithm/is_heap_until.h" }
       module is_partitioned           { private header "__algorithm/is_partitioned.h" }
       module is_permutation           { private header "__algorithm/is_permutation.h" }
       module is_sorted                { private header "__algorithm/is_sorted.h" }
       module is_sorted_until          { private header "__algorithm/is_sorted_until.h" }
       module iter_swap                { private header "__algorithm/iter_swap.h" }
       module lexicographical_compare  { private header "__algorithm/lexicographical_compare.h" }
       module lower_bound              { private header "__algorithm/lower_bound.h" }
       module make_heap                { private header "__algorithm/make_heap.h" }
       module max                      { private header "__algorithm/max.h" }
       module max_element              { private header "__algorithm/max_element.h" }
       module merge                    { private header "__algorithm/merge.h" }
       module min                      { private header "__algorithm/min.h" }
       module min_element              { private header "__algorithm/min_element.h" }
       module minmax                   { private header "__algorithm/minmax.h" }
       module minmax_element           { private header "__algorithm/minmax_element.h" }
       module mismatch                 { private header "__algorithm/mismatch.h" }
       module move                     { private header "__algorithm/move.h" }
       module move_backward            { private header "__algorithm/move_backward.h" }
       module next_permutation         { private header "__algorithm/next_permutation.h" }
       module none_of                  { private header "__algorithm/none_of.h" }
       module nth_element              { private header "__algorithm/nth_element.h" }
       module partial_sort             { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
       module partition                { private header "__algorithm/partition.h" }
       module partition_copy           { private header "__algorithm/partition_copy.h" }
       module partition_point          { private header "__algorithm/partition_point.h" }
       module pop_heap                 { private header "__algorithm/pop_heap.h" }
       module prev_permutation         { private header "__algorithm/prev_permutation.h" }
       module push_heap                { private header "__algorithm/push_heap.h" }
       module remove                   { private header "__algorithm/remove.h" }
       module remove_copy              { private header "__algorithm/remove_copy.h" }
       module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
       module remove_if                { private header "__algorithm/remove_if.h" }
       module replace                  { private header "__algorithm/replace.h" }
       module replace_copy             { private header "__algorithm/replace_copy.h" }
       module replace_copy_if          { private header "__algorithm/replace_copy_if.h" }
       module replace_if               { private header "__algorithm/replace_if.h" }
       module reverse                  { private header "__algorithm/reverse.h" }
       module reverse_copy             { private header "__algorithm/reverse_copy.h" }
       module rotate                   { private header "__algorithm/rotate.h" }
       module rotate_copy              { private header "__algorithm/rotate_copy.h" }
       module sample                   { private header "__algorithm/sample.h" }
       module search                   { private header "__algorithm/search.h" }
       module search_n                 { private header "__algorithm/search_n.h" }
       module set_difference           { private header "__algorithm/set_difference.h" }
       module set_intersection         { private header "__algorithm/set_intersection.h" }
       module set_symmetric_difference { private header "__algorithm/set_symmetric_difference.h" }
       module set_union                { private header "__algorithm/set_union.h" }
       module shift_left               { private header "__algorithm/shift_left.h" }
       module shift_right              { private header "__algorithm/shift_right.h" }
       module shuffle                  { private header "__algorithm/shuffle.h" }
       module sift_down                { private header "__algorithm/sift_down.h" }
       module sort                     { private header "__algorithm/sort.h" }
       module sort_heap                { private header "__algorithm/sort_heap.h" }
       module stable_partition         { private header "__algorithm/stable_partition.h" }
       module stable_sort              { private header "__algorithm/stable_sort.h" }
       module swap_ranges              { private header "__algorithm/swap_ranges.h" }
       module transform                { private header "__algorithm/transform.h" }
       module unique                   { private header "__algorithm/unique.h" }
       module unique_copy              { private header "__algorithm/unique_copy.h" }
       module unwrap_iter              { private header "__algorithm/unwrap_iter.h" }
       module upper_bound              { private header "__algorithm/upper_bound.h" }
     }
   }
   module any {
     header "any"
     export *
   }
   module array {
     header "array"
     export initializer_list
     export *
   }
   module atomic {
     header "atomic"
     export *
   }
   module barrier {
     requires cplusplus14
     header "barrier"
     export *
   }
   module bit {
     header "bit"
     export *
 
     module __bit {
       module bit_cast { private header "__bit/bit_cast.h" }
       module byteswap { private header "__bit/byteswap.h" }
     }
   }
   module bitset {
     header "bitset"
     export string
     export iosfwd
     export *
   }
   // No submodule for cassert. It fundamentally needs repeated, textual inclusion.
   module charconv {
     header "charconv"
     export *
 
     module __charconv {
       module chars_format      { private header "__charconv/chars_format.h" }
       module from_chars_result { private header "__charconv/from_chars_result.h" }
       module to_chars_result   { private header "__charconv/to_chars_result.h" }
     }
 
   }
   module chrono {
     header "chrono"
     export *
 
     module __chrono {
       module calendar              { private header "__chrono/calendar.h" }
       module convert_to_timespec   { private header "__chrono/convert_to_timespec.h" }
       module duration              { private header "__chrono/duration.h" }
       module file_clock            { private header "__chrono/file_clock.h" }
       module high_resolution_clock { private header "__chrono/high_resolution_clock.h" }
       module steady_clock          { private header "__chrono/steady_clock.h" }
       module system_clock          { private header "__chrono/system_clock.h" }
       module time_point            { private header "__chrono/time_point.h" }
     }
   }
   module codecvt {
     header "codecvt"
     export *
   }
   module compare {
     header "compare"
     export *
 
     module __compare {
       module common_comparison_category     { private header "__compare/common_comparison_category.h" }
       module compare_partial_order_fallback { private header "__compare/compare_partial_order_fallback.h" }
       module compare_strong_order_fallback  { private header "__compare/compare_strong_order_fallback.h" }
       module compare_three_way              { private header "__compare/compare_three_way.h" }
       module compare_three_way_result       { private header "__compare/compare_three_way_result.h" }
       module compare_weak_order_fallback    { private header "__compare/compare_weak_order_fallback.h" }
       module is_eq                          { private header "__compare/is_eq.h" }
       module ordering                       { private header "__compare/ordering.h" }
       module partial_order                  { private header "__compare/partial_order.h" }
       module strong_order                   { private header "__compare/strong_order.h" }
       module synth_three_way                { private header "__compare/synth_three_way.h" }
       module three_way_comparable           { private header "__compare/three_way_comparable.h" }
       module weak_order                     { private header "__compare/weak_order.h" }
     }
   }
   module complex {
     header "complex"
     export *
   }
   module concepts {
     header "concepts"
     export *
 
     module __concepts {
       module arithmetic                 { private header "__concepts/arithmetic.h" }
       module assignable                 { private header "__concepts/assignable.h" }
       module boolean_testable           { private header "__concepts/boolean_testable.h" }
       module class_or_enum              { private header "__concepts/class_or_enum.h" }
       module common_reference_with      { private header "__concepts/common_reference_with.h" }
       module common_with                { private header "__concepts/common_with.h" }
       module constructible              { private header "__concepts/constructible.h" }
       module convertible_to             { private header "__concepts/convertible_to.h" }
       module copyable                   { private header "__concepts/copyable.h" }
       module derived_from               { private header "__concepts/derived_from.h" }
       module destructible               { private header "__concepts/destructible.h" }
       module different_from             { private header "__concepts/different_from.h" }
       module equality_comparable        { private header "__concepts/equality_comparable.h" }
       module invocable                  { private header "__concepts/invocable.h" }
       module movable                    { private header "__concepts/movable.h" }
       module predicate                  { private header "__concepts/predicate.h" }
       module regular                    { private header "__concepts/regular.h" }
       module relation                   { private header "__concepts/relation.h" }
       module same_as                    { private header "__concepts/same_as.h" }
       module semiregular                { private header "__concepts/semiregular.h" }
       module swappable                  { private header "__concepts/swappable.h" }
       module totally_ordered            { private header "__concepts/totally_ordered.h" }
     }
   }
   module condition_variable {
     header "condition_variable"
     export *
   }
   module coroutine {
     requires coroutines
     header "coroutine"
     export compare
     export *
 
     module __coroutine {
       module coroutine_handle           { private header "__coroutine/coroutine_handle.h" }
       module coroutine_traits           { private header "__coroutine/coroutine_traits.h" }
       module noop_coroutine_handle      { private header "__coroutine/noop_coroutine_handle.h" }
       module trivial_awaitables         { private header "__coroutine/trivial_awaitables.h" }
     }
   }
   module deque {
     header "deque"
     export initializer_list
     export *
   }
   module exception {
     header "exception"
     export *
   }
   module execution {
     header "execution"
     export *
   }
   module filesystem {
     header "filesystem"
     export *
 
     module __filesystem {
       module copy_options                 { private header "__filesystem/copy_options.h" }
       module directory_entry              { private header "__filesystem/directory_entry.h" }
       module directory_iterator           { private header "__filesystem/directory_iterator.h" }
       module directory_options            { private header "__filesystem/directory_options.h" }
       module file_status                  { private header "__filesystem/file_status.h" }
       module file_time_type               { private header "__filesystem/file_time_type.h" }
       module file_type                    { private header "__filesystem/file_type.h" }
       module filesystem_error             { private header "__filesystem/filesystem_error.h" }
       module operations                   { private header "__filesystem/operations.h" }
       module path                         { private header "__filesystem/path.h" }
       module path_iterator                { private header "__filesystem/path_iterator.h" }
       module perm_options                 { private header "__filesystem/perm_options.h" }
       module perms                        { private header "__filesystem/perms.h" }
       module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" }
       module space_info                   { private header "__filesystem/space_info.h" }
       module u8path                       { private header "__filesystem/u8path.h" }
     }
   }
   module format {
     header "format"
     export *
 
     module __format {
       module format_arg               { private header "__format/format_arg.h" }
       module format_args              { private header "__format/format_args.h" }
       module format_context {
         private header "__format/format_context.h"
         export optional
         export locale
       }
       module format_error             { private header "__format/format_error.h" }
       module format_fwd               { private header "__format/format_fwd.h" }
       module format_parse_context     { private header "__format/format_parse_context.h" }
       module format_string            { private header "__format/format_string.h" }
       module format_to_n_result       { private header "__format/format_to_n_result.h" }
       module formatter                { private header "__format/formatter.h" }
       module formatter_bool           { private header "__format/formatter_bool.h" }
       module formatter_char           { private header "__format/formatter_char.h" }
       module formatter_floating_point { private header "__format/formatter_floating_point.h" }
       module formatter_integer        { private header "__format/formatter_integer.h" }
       module formatter_integral       { private header "__format/formatter_integral.h" }
       module formatter_pointer        { private header "__format/formatter_pointer.h" }
       module formatter_string         { private header "__format/formatter_string.h" }
       module parser_std_format_spec   { private header "__format/parser_std_format_spec.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {
     header "fstream"
     export *
   }
   module functional {
     header "functional"
     export *
 
     module __functional {
       module binary_function            { private header "__functional/binary_function.h" }
       module binary_negate              { private header "__functional/binary_negate.h" }
       module bind                       { private header "__functional/bind.h" }
       module bind_back                  { private header "__functional/bind_back.h" }
       module bind_front                 { private header "__functional/bind_front.h" }
       module binder1st                  { private header "__functional/binder1st.h" }
       module binder2nd                  { private header "__functional/binder2nd.h" }
       module compose                    { private header "__functional/compose.h" }
       module default_searcher           { private header "__functional/default_searcher.h" }
       module function                   { private header "__functional/function.h" }
       module hash                       { private header "__functional/hash.h" }
       module identity                   { private header "__functional/identity.h" }
       module invoke                     { private header "__functional/invoke.h" }
       module is_transparent             { private header "__functional/is_transparent.h" }
       module mem_fn                     { private header "__functional/mem_fn.h" }
       module mem_fun_ref                { private header "__functional/mem_fun_ref.h" }
       module not_fn                     { private header "__functional/not_fn.h" }
       module operations                 { private header "__functional/operations.h" }
       module perfect_forward            { private header "__functional/perfect_forward.h" }
       module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
       module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
       module ranges_operations          { private header "__functional/ranges_operations.h" }
       module reference_wrapper          { private header "__functional/reference_wrapper.h" }
       module unary_function             { private header "__functional/unary_function.h" }
       module unary_negate               { private header "__functional/unary_negate.h" }
       module unwrap_ref                 { private header "__functional/unwrap_ref.h" }
       module weak_result_type           { private header "__functional/weak_result_type.h" }
     }
   }
   module future {
     header "future"
     export *
   }
   module initializer_list {
     header "initializer_list"
     export *
   }
   module iomanip {
     header "iomanip"
     export *
   }
   module ios {
     header "ios"
     export iosfwd
     export *
   }
   module iosfwd {
     header "iosfwd"
     export *
   }
   module iostream {
     header "iostream"
     export ios
     export streambuf
     export istream
     export ostream
     export *
   }
   module istream {
     header "istream"
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module iterator {
     header "iterator"
     export *
 
     module __iterator {
       module access                { private header "__iterator/access.h" }
       module advance               { private header "__iterator/advance.h" }
       module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
       module common_iterator       { private header "__iterator/common_iterator.h" }
       module concepts              { private header "__iterator/concepts.h" }
       module counted_iterator      { private header "__iterator/counted_iterator.h" }
       module data                  { private header "__iterator/data.h" }
       module default_sentinel      { private header "__iterator/default_sentinel.h" }
       module distance              { private header "__iterator/distance.h" }
       module empty                 { private header "__iterator/empty.h" }
       module erase_if_container    { private header "__iterator/erase_if_container.h" }
       module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
       module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
       module indirectly_comparable { private header "__iterator/indirectly_comparable.h" }
       module insert_iterator       { private header "__iterator/insert_iterator.h" }
       module istream_iterator      { private header "__iterator/istream_iterator.h" }
       module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
       module iter_move             { private header "__iterator/iter_move.h" }
       module iter_swap             { private header "__iterator/iter_swap.h" }
       module iterator              { private header "__iterator/iterator.h" }
       module iterator_traits       { private header "__iterator/iterator_traits.h" }
       module move_iterator         { private header "__iterator/move_iterator.h" }
       module next                  { private header "__iterator/next.h" }
       module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
       module ostreambuf_iterator   { private header "__iterator/ostreambuf_iterator.h" }
       module prev                  { private header "__iterator/prev.h" }
       module projected             { private header "__iterator/projected.h" }
       module readable_traits       { private header "__iterator/readable_traits.h" }
       module reverse_access        { private header "__iterator/reverse_access.h" }
       module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
       module size                  { private header "__iterator/size.h" }
       module unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
       module wrap_iter             { private header "__iterator/wrap_iter.h" }
     }
   }
   module latch {
     requires cplusplus14
     header "latch"
     export *
   }
   module limits {
     header "limits"
     export *
   }
   module list {
     header "list"
     export initializer_list
     export *
   }
   module locale {
     header "locale"
     export *
   }
   module map {
     header "map"
     export initializer_list
     export *
   }
   module memory {
     header "memory"
     export *
 
     module __memory {
       module addressof                       { private header "__memory/addressof.h" }
       module allocation_guard                { private header "__memory/allocation_guard.h" }
       module allocator                       { private header "__memory/allocator.h" }
       module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
       module allocator_traits                { private header "__memory/allocator_traits.h" }
       module auto_ptr                        { private header "__memory/auto_ptr.h" }
       module compressed_pair                 { private header "__memory/compressed_pair.h" }
       module concepts                        { private header "__memory/concepts.h" }
       module construct_at                    { private header "__memory/construct_at.h" }
       module pointer_traits                  { private header "__memory/pointer_traits.h" }
       module ranges_construct_at             { private header "__memory/ranges_construct_at.h" }
       module ranges_uninitialized_algorithms { private header "__memory/ranges_uninitialized_algorithms.h" }
       module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
       module shared_ptr                      { private header "__memory/shared_ptr.h" }
       module temporary_buffer                { private header "__memory/temporary_buffer.h" }
       module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }
       module unique_ptr                      { private header "__memory/unique_ptr.h" }
       module uses_allocator                  { private header "__memory/uses_allocator.h" }
       module voidify                         { private header "__memory/voidify.h" }
     }
   }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
     export *
   }
   module numbers {
     header "numbers"
     export *
   }
   module numeric {
     header "numeric"
     export *
 
     module __numeric {
       module accumulate               { private header "__numeric/accumulate.h" }
       module adjacent_difference      { private header "__numeric/adjacent_difference.h" }
       module exclusive_scan           { private header "__numeric/exclusive_scan.h" }
       module gcd_lcm                  { private header "__numeric/gcd_lcm.h" }
       module inclusive_scan           { private header "__numeric/inclusive_scan.h" }
       module inner_product            { private header "__numeric/inner_product.h" }
       module iota                     { private header "__numeric/iota.h" }
       module midpoint                 { private header "__numeric/midpoint.h" }
       module partial_sum              { private header "__numeric/partial_sum.h" }
       module reduce                   { private header "__numeric/reduce.h" }
       module transform_exclusive_scan { private header "__numeric/transform_exclusive_scan.h" }
       module transform_inclusive_scan { private header "__numeric/transform_inclusive_scan.h" }
       module transform_reduce         { private header "__numeric/transform_reduce.h" }
     }
   }
   module optional {
     header "optional"
     export *
   }
   module ostream {
     header "ostream"
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module queue {
     header "queue"
     export initializer_list
     export *
   }
   module random {
     header "random"
     export initializer_list
     export *
 
     module __random {
       module bernoulli_distribution          { private header "__random/bernoulli_distribution.h" }
       module binomial_distribution           { private header "__random/binomial_distribution.h" }
       module cauchy_distribution             { private header "__random/cauchy_distribution.h" }
       module chi_squared_distribution        { private header "__random/chi_squared_distribution.h" }
       module clamp_to_integral               { private header "__random/clamp_to_integral.h" }
       module default_random_engine           { private header "__random/default_random_engine.h" }
       module discard_block_engine            { private header "__random/discard_block_engine.h" }
       module discrete_distribution           { private header "__random/discrete_distribution.h" }
       module exponential_distribution        { private header "__random/exponential_distribution.h" }
       module extreme_value_distribution      { private header "__random/extreme_value_distribution.h" }
       module fisher_f_distribution           { private header "__random/fisher_f_distribution.h" }
       module gamma_distribution              { private header "__random/gamma_distribution.h" }
       module generate_canonical              { private header "__random/generate_canonical.h" }
       module geometric_distribution          { private header "__random/geometric_distribution.h" }
       module independent_bits_engine         { private header "__random/independent_bits_engine.h" }
       module is_seed_sequence                { private header "__random/is_seed_sequence.h" }
       module knuth_b                         { private header "__random/knuth_b.h" }
       module linear_congruential_engine      { private header "__random/linear_congruential_engine.h" }
       module log2                            { private header "__random/log2.h" }
       module lognormal_distribution          { private header "__random/lognormal_distribution.h" }
       module mersenne_twister_engine         { private header "__random/mersenne_twister_engine.h" }
       module negative_binomial_distribution  { private header "__random/negative_binomial_distribution.h" }
       module normal_distribution             { private header "__random/normal_distribution.h" }
       module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" }
       module piecewise_linear_distribution   { private header "__random/piecewise_linear_distribution.h" }
       module poisson_distribution            { private header "__random/poisson_distribution.h" }
       module random_device                   { private header "__random/random_device.h" }
       module ranlux                          { private header "__random/ranlux.h" }
       module seed_seq                        { private header "__random/seed_seq.h" }
       module shuffle_order_engine            { private header "__random/shuffle_order_engine.h" }
       module student_t_distribution          { private header "__random/student_t_distribution.h" }
       module subtract_with_carry_engine      { private header "__random/subtract_with_carry_engine.h" }
       module uniform_int_distribution        { private header "__random/uniform_int_distribution.h" }
       module uniform_random_bit_generator    { private header "__random/uniform_random_bit_generator.h" }
       module uniform_real_distribution       { private header "__random/uniform_real_distribution.h" }
       module weibull_distribution            { private header "__random/weibull_distribution.h" }
     }
   }
   module ranges {
     header "ranges"
     export compare
     export initializer_list
     export iterator
     export *
 
     module __ranges {
       module access                 { private header "__ranges/access.h" }
       module all                    {
         private header "__ranges/all.h"
         export functional.__functional.compose
         export functional.__functional.perfect_forward
       }
       module common_view            { private header "__ranges/common_view.h" }
       module concepts               { private header "__ranges/concepts.h" }
       module copyable_box           { private header "__ranges/copyable_box.h" }
       module counted                {
         private header "__ranges/counted.h"
         export span
       }
       module dangling               { private header "__ranges/dangling.h" }
       module data                   { private header "__ranges/data.h" }
       module drop_view              { private header "__ranges/drop_view.h" }
       module empty                  { private header "__ranges/empty.h" }
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module join_view              { private header "__ranges/join_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
       module reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }
       module size                   { private header "__ranges/size.h" }
       module subrange               { private header "__ranges/subrange.h" }
       module take_view              { private header "__ranges/take_view.h" }
       module transform_view         {
         private header "__ranges/transform_view.h"
         export functional.__functional.bind_back
         export functional.__functional.perfect_forward
       }
       module view_interface         { private header "__ranges/view_interface.h" }
+      module views                  { private header "__ranges/views.h" }
     }
   }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
     header "regex"
     export initializer_list
     export *
   }
   module scoped_allocator {
     header "scoped_allocator"
     export *
   }
   module semaphore {
     requires cplusplus14
     header "semaphore"
     export *
   }
   module set {
     header "set"
     export initializer_list
     export *
   }
   module shared_mutex {
     header "shared_mutex"
     export version
   }
   module span {
     header "span"
     export ranges.__ranges.enable_borrowed_range
     export version
   }
   module sstream {
     header "sstream"
     // FIXME: should re-export istream, ostream, ios, streambuf, string?
     export *
   }
   module stack {
     header "stack"
     export initializer_list
     export *
   }
   module stdexcept {
     header "stdexcept"
     export *
   }
   module streambuf {
     header "streambuf"
     export *
   }
   module string {
     header "string"
     export initializer_list
     export string_view
     export __string
     export *
   }
   module string_view {
     header "string_view"
     export initializer_list
     export __string
     export *
   }
   module strstream {
     header "strstream"
     export *
   }
   module system_error {
     header "system_error"
     export *
   }
   module thread {
     header "thread"
     export *
 
     module __thread {
       module poll_with_backoff    { private header "__thread/poll_with_backoff.h" }
       module timed_backoff_policy { private header "__thread/timed_backoff_policy.h" }
     }
   }
   module tuple {
     header "tuple"
     export *
   }
   module type_traits {
     header "type_traits"
     export functional.__functional.unwrap_ref
     export *
   }
   module typeindex {
     header "typeindex"
     export *
   }
   module typeinfo {
     header "typeinfo"
     export *
   }
   module unordered_map {
     header "unordered_map"
     export initializer_list
     export *
   }
   module unordered_set {
     header "unordered_set"
     export initializer_list
     export *
   }
   module utility {
     header "utility"
     export initializer_list
     export *
 
     module __utility {
       module as_const            { private header "__utility/as_const.h" }
       module auto_cast           { private header "__utility/auto_cast.h" }
       module cmp                 { private header "__utility/cmp.h" }
       module declval             { private header "__utility/declval.h" }
       module exchange            { private header "__utility/exchange.h" }
       module forward             { private header "__utility/forward.h" }
       module in_place            { private header "__utility/in_place.h" }
       module integer_sequence    { private header "__utility/integer_sequence.h" }
       module move                { private header "__utility/move.h" }
       module pair                { private header "__utility/pair.h" }
       module piecewise_construct { private header "__utility/piecewise_construct.h" }
       module priority_tag        { private header "__utility/priority_tag.h" }
       module rel_ops             { private header "__utility/rel_ops.h" }
       module swap                { private header "__utility/swap.h" }
       module to_underlying       { private header "__utility/to_underlying.h" }
       module transaction         { private header "__utility/transaction.h" }
     }
   }
   module valarray {
     header "valarray"
     export initializer_list
     export *
   }
   module variant {
     header "variant"
     export *
 
     module __variant {
       module monostate { private header "__variant/monostate.h" }
     }
   }
   module vector {
     header "vector"
     export initializer_list
     export *
   }
   module version {
     header "version"
     export *
   }
 
   // __config not modularised due to a bug in Clang
   // FIXME: These should be private.
   module __availability      { private header "__availability"      export * }
   module __bit_reference     { private header "__bit_reference"     export * }
   module __bits              { private header "__bits"              export * }
   module __debug             {         header "__debug"             export * }
   module __errc              { private header "__errc"              export * }
   module __hash_table        {         header "__hash_table"        export * }
   module __locale            { private header "__locale"            export * }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }
   module __mutex_base        { private header "__mutex_base"        export * }
   module __node_handle       { private header "__node_handle"       export * }
   module __nullptr           {         header "__nullptr"           export * }
   module __split_buffer      { private header "__split_buffer"      export * }
   module __std_stream        { private header "__std_stream"        export * }
   module __string            { private header "__string"            export * }
   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }
   module __tuple             { private header "__tuple"             export * }
   module __undef_macros      {         header "__undef_macros"      export * }
 
   module experimental {
     requires cplusplus11
 
     module algorithm {
       header "experimental/algorithm"
       export *
     }
      module coroutine {
       requires coroutines
       header "experimental/coroutine"
       export *
     }
     module deque {
       header "experimental/deque"
       export *
     }
     module filesystem {
       header "experimental/filesystem"
       export *
     }
     module forward_list {
       header "experimental/forward_list"
       export *
     }
     module functional {
       header "experimental/functional"
       export *
     }
     module iterator {
       header "experimental/iterator"
       export *
     }
     module list {
       header "experimental/list"
       export *
     }
     module map {
       header "experimental/map"
       export *
     }
     module memory_resource {
       header "experimental/memory_resource"
       export *
     }
     module propagate_const {
       header "experimental/propagate_const"
       export *
     }
     module regex {
       header "experimental/regex"
       export *
     }
     module simd {
       header "experimental/simd"
       export *
     }
     module set {
       header "experimental/set"
       export *
     }
     module span {
       header "span"
       export *
     }
     module string {
       header "experimental/string"
       export *
     }
     module type_traits {
       header "experimental/type_traits"
       export *
     }
     module unordered_map {
       header "experimental/unordered_map"
       export *
     }
     module unordered_set {
       header "experimental/unordered_set"
       export *
     }
     module utility {
       header "experimental/utility"
       export *
     }
     module vector {
       header "experimental/vector"
       export *
     }
     // FIXME these should be private
     module __memory {
       header "experimental/__memory"
       export *
     }
   } // end experimental
 }
diff --git a/contrib/llvm-project/libcxx/include/ranges b/contrib/llvm-project/libcxx/include/ranges
index 82ad7f4d507f..9b831160d683 100644
--- a/contrib/llvm-project/libcxx/include/ranges
+++ b/contrib/llvm-project/libcxx/include/ranges
@@ -1,246 +1,237 @@
 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_RANGES
 #define _LIBCPP_RANGES
 
 /*
 
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 #include <iterator>             // see [iterator.synopsis]
 
 namespace std::ranges {
   inline namespace unspecified {
     // [range.access], range access
     inline constexpr unspecified begin = unspecified;
     inline constexpr unspecified end = unspecified;
     inline constexpr unspecified cbegin = unspecified;
     inline constexpr unspecified cend = unspecified;
 
     inline constexpr unspecified size = unspecified;
     inline constexpr unspecified ssize = unspecified;
   }
 
   // [range.range], ranges
   template<class T>
     concept range = see below;
 
   template<class T>
     inline constexpr bool enable_borrowed_range = false;
 
   template<class T>
     using iterator_t = decltype(ranges::begin(declval<T&>()));
   template<range R>
     using sentinel_t = decltype(ranges::end(declval<R&>()));
   template<range R>
     using range_difference_t = iter_difference_t<iterator_t<R>>;
   template<sized_range R>
     using range_size_t = decltype(ranges::size(declval<R&>()));
   template<range R>
     using range_value_t = iter_value_t<iterator_t<R>>;
   template<range R>
     using range_reference_t = iter_reference_t<iterator_t<R>>;
   template<range R>
     using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
 
   // [range.sized], sized ranges
   template<class>
     inline constexpr bool disable_sized_range = false;
 
   template<class T>
     concept sized_range = ...;
 
   // [range.view], views
   template<class T>
     inline constexpr bool enable_view = ...;
 
   struct view_base { };
 
   template<class T>
     concept view = ...;
 
   // [range.refinements], other range refinements
   template<class R, class T>
     concept output_range = see below;
 
   template<class T>
     concept input_range = see below;
 
   template<class T>
     concept forward_range = see below;
 
   template<class T>
   concept bidirectional_range = see below;
 
   template<class T>
   concept random_access_range = see below;
 
   template<class T>
   concept contiguous_range = see below;
 
   template <class _Tp>
     concept common_range = see below;
 
   template<class T>
   concept viewable_range = see below;
 
   // [view.interface], class template view_interface
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
   class view_interface;
 
   // [range.subrange], sub-ranges
   enum class subrange_kind : bool { unsized, sized };
 
   template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = see below>
     requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
   class subrange;
 
   template<class I, class S, subrange_kind K>
     inline constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
 
   // [range.dangling], dangling iterator handling
   struct dangling;
 
   template<range R>
     using borrowed_iterator_t = see below;
 
   template<range R>
     using borrowed_subrange_t = see below;
 
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
   class empty_view;
 
   // [range.all], all view
   namespace views {
     inline constexpr unspecified all = unspecified;
 
     template<viewable_range R>
       using all_t = decltype(all(declval<R>()));
   }
 
   template<range R>
     requires is_object_v<R>
   class ref_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<ref_view<T>> = true;
 
   template<range R>
     requires see below
   class owning_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>;
 
   // [range.drop], drop view
   template<view V>
     class drop_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
 
   // [range.transform], transform view
   template<input_range V, copy_constructible F>
     requires view<V> && is_object_v<F> &&
              regular_invocable<F&, range_reference_t<V>> &&
              can-reference<invoke_result_t<F&, range_reference_t<V>>>
   class transform_view;
 
   // [range.counted], counted view
   namespace views { inline constexpr unspecified counted = unspecified; }
 
   // [range.common], common view
   template<view V>
     requires (!common_range<V> && copyable<iterator_t<V>>)
   class common_view;
 
  // [range.reverse], reverse view
   template<view V>
     requires bidirectional_range<V>
   class reverse_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<reverse_view<T>> = enable_borrowed_range<T>;
 
   template<class T>
   inline constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
 
    // [range.take], take view
   template<view> class take_view;
 
   template<class T>
   inline constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
 
   template<copy_constructible T>
     requires is_object_v<T>
   class single_view;
 
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
     requires weakly-equality-comparable-with<W, Bound> && copyable<W>
   class iota_view;
 
   template<class W, class Bound>
     inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 
   // [range.join], join view
   template<input_range V>
     requires view<V> && input_range<range_reference_t<V>>
   class join_view;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/counted.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
+#include <__ranges/views.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace views = ranges::views;
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
-
 #endif // _LIBCPP_RANGES
diff --git a/lib/libc++/Makefile b/lib/libc++/Makefile
index 5f4db2fd595c..e5bf55e37804 100644
--- a/lib/libc++/Makefile
+++ b/lib/libc++/Makefile
@@ -1,751 +1,752 @@
 # $FreeBSD$
 
 SHLIBDIR?=	/lib
 
 .include <src.opts.mk>
 
 PACKAGE=	clibs
 _LIBCXXRTDIR=	${SRCTOP}/contrib/libcxxrt
 HDRDIR=		${SRCTOP}/contrib/llvm-project/libcxx/include
 SRCDIR=		${SRCTOP}/contrib/llvm-project/libcxx/src
 CXXINCLUDEDIR=	${INCLUDEDIR}/c++/v${SHLIB_MAJOR}
 
 .PATH: ${SRCDIR}
 
 LIB=		c++
 SHLIB_MAJOR=	1
 SHLIB_LDSCRIPT=	libc++.ldscript
 
 SRCS+=		algorithm.cpp
 SRCS+=		any.cpp
 SRCS+=		atomic.cpp
 SRCS+=		barrier.cpp
 SRCS+=		bind.cpp
 SRCS+=		charconv.cpp
 SRCS+=		chrono.cpp
 SRCS+=		condition_variable.cpp
 SRCS+=		condition_variable_destructor.cpp
 SRCS+=		debug.cpp
 SRCS+=		exception.cpp
 SRCS+=		filesystem/directory_iterator.cpp
 SRCS+=		filesystem/int128_builtins.cpp
 SRCS+=		filesystem/operations.cpp
 SRCS+=		format.cpp
 SRCS+=		functional.cpp
 SRCS+=		future.cpp
 SRCS+=		hash.cpp
 SRCS+=		ios.cpp
 SRCS+=		ios.instantiations.cpp
 SRCS+=		iostream.cpp
 SRCS+=		legacy_pointer_safety.cpp
 SRCS+=		locale.cpp
 SRCS+=		memory.cpp
 SRCS+=		mutex.cpp
 SRCS+=		mutex_destructor.cpp
 SRCS+=		new.cpp
 SRCS+=		optional.cpp
 SRCS+=		random.cpp
 SRCS+=		random_shuffle.cpp
 SRCS+=		regex.cpp
 SRCS+=		ryu/d2fixed.cpp
 SRCS+=		ryu/d2s.cpp
 SRCS+=		ryu/f2s.cpp
 SRCS+=		shared_mutex.cpp
 SRCS+=		stdexcept.cpp
 SRCS+=		string.cpp
 SRCS+=		strstream.cpp
 SRCS+=		system_error.cpp
 SRCS+=		thread.cpp
 SRCS+=		typeinfo.cpp
 SRCS+=		utility.cpp
 SRCS+=		valarray.cpp
 SRCS+=		variant.cpp
 SRCS+=		vector.cpp
 
 CXXRT_SRCS+=	auxhelper.cc
 CXXRT_SRCS+=	dynamic_cast.cc
 CXXRT_SRCS+=	exception.cc
 CXXRT_SRCS+=	guard.cc
 CXXRT_SRCS+=	libelftc_dem_gnu3.c
 CXXRT_SRCS+=	memory.cc
 CXXRT_SRCS+=	stdexcept.cc
 CXXRT_SRCS+=	terminate.cc
 CXXRT_SRCS+=	typeinfo.cc
 
 .for _S in ${CXXRT_SRCS}
 CLEANFILES+=	cxxrt_${_S}
 STATICOBJS+=	cxxrt_${_S:R}.o
 cxxrt_${_S}: ${_LIBCXXRTDIR}/${_S} .NOMETA
 	ln -sf ${.ALLSRC} ${.TARGET}
 .endfor
 
 WARNS?=		0
 CFLAGS+=	-isystem ${.CURDIR}
 CFLAGS+=	-isystem ${HDRDIR}
 CFLAGS+=	-isystem ${SRCDIR}
 CFLAGS+=	-isystem ${_LIBCXXRTDIR}
 CFLAGS+=	-nostdinc++
 CFLAGS+=	-nostdlib
 CFLAGS+=	-D_LIBCPP_BUILDING_LIBRARY
 CFLAGS+=	-DLIBCXXRT
 CFLAGS+=	-ffunction-sections
 CFLAGS+=	-fdata-sections
 CXXSTD?=	c++20
 
 LIBADD+=	cxxrt
 
 INCSGROUPS+=	STD
 STDDIR=		${CXXINCLUDEDIR}
 STD_HEADERS+=	__availability
 STD_HEADERS+=	__bit_reference
 STD_HEADERS+=	__bits
 STD_HEADERS+=	__bsd_locale_defaults.h
 STD_HEADERS+=	__bsd_locale_fallbacks.h
 STD_HEADERS+=	__config
 STD_HEADERS+=	__debug
 STD_HEADERS+=	__errc
 STD_HEADERS+=	__functional_base
 STD_HEADERS+=	__hash_table
 STD_HEADERS+=	__libcpp_version
 STD_HEADERS+=	__locale
 STD_HEADERS+=	__mbstate_t.h
 STD_HEADERS+=	__mutex_base
 STD_HEADERS+=	__node_handle
 STD_HEADERS+=	__nullptr
 STD_HEADERS+=	__split_buffer
 STD_HEADERS+=	__std_stream
 STD_HEADERS+=	__string
 STD_HEADERS+=	__threading_support
 STD_HEADERS+=	__tree
 STD_HEADERS+=	__tuple
 STD_HEADERS+=	__undef_macros
 STD_HEADERS+=	algorithm
 STD_HEADERS+=	any
 STD_HEADERS+=	array
 STD_HEADERS+=	atomic
 STD_HEADERS+=	barrier
 STD_HEADERS+=	bit
 STD_HEADERS+=	bitset
 STD_HEADERS+=	cassert
 STD_HEADERS+=	ccomplex
 STD_HEADERS+=	cctype
 STD_HEADERS+=	cerrno
 STD_HEADERS+=	cfenv
 STD_HEADERS+=	cfloat
 STD_HEADERS+=	charconv
 STD_HEADERS+=	chrono
 STD_HEADERS+=	cinttypes
 STD_HEADERS+=	ciso646
 STD_HEADERS+=	climits
 STD_HEADERS+=	clocale
 STD_HEADERS+=	cmath
 STD_HEADERS+=	codecvt
 STD_HEADERS+=	compare
 STD_HEADERS+=	complex
 STD_HEADERS+=	complex.h
 STD_HEADERS+=	concepts
 STD_HEADERS+=	condition_variable
 STD_HEADERS+=	coroutine
 STD_HEADERS+=	csetjmp
 STD_HEADERS+=	csignal
 STD_HEADERS+=	cstdarg
 STD_HEADERS+=	cstdbool
 STD_HEADERS+=	cstddef
 STD_HEADERS+=	cstdint
 STD_HEADERS+=	cstdio
 STD_HEADERS+=	cstdlib
 STD_HEADERS+=	cstring
 STD_HEADERS+=	ctgmath
 STD_HEADERS+=	ctime
 STD_HEADERS+=	ctype.h
 STD_HEADERS+=	cwchar
 STD_HEADERS+=	cwctype
 STD_HEADERS+=	deque
 STD_HEADERS+=	errno.h
 STD_HEADERS+=	exception
 STD_HEADERS+=	execution
 STD_HEADERS+=	fenv.h
 STD_HEADERS+=	filesystem
 STD_HEADERS+=	float.h
 STD_HEADERS+=	format
 STD_HEADERS+=	forward_list
 STD_HEADERS+=	fstream
 STD_HEADERS+=	functional
 STD_HEADERS+=	future
 STD_HEADERS+=	initializer_list
 STD_HEADERS+=	inttypes.h
 STD_HEADERS+=	iomanip
 STD_HEADERS+=	ios
 STD_HEADERS+=	iosfwd
 STD_HEADERS+=	iostream
 STD_HEADERS+=	istream
 STD_HEADERS+=	iterator
 STD_HEADERS+=	latch
 STD_HEADERS+=	limits
 STD_HEADERS+=	limits.h
 STD_HEADERS+=	list
 STD_HEADERS+=	locale
 STD_HEADERS+=	locale.h
 STD_HEADERS+=	map
 STD_HEADERS+=	math.h
 STD_HEADERS+=	memory
 STD_HEADERS+=	module.modulemap
 STD_HEADERS+=	mutex
 STD_HEADERS+=	new
 STD_HEADERS+=	numbers
 STD_HEADERS+=	numeric
 STD_HEADERS+=	optional
 STD_HEADERS+=	ostream
 STD_HEADERS+=	queue
 STD_HEADERS+=	random
 STD_HEADERS+=	ranges
 STD_HEADERS+=	ratio
 STD_HEADERS+=	regex
 STD_HEADERS+=	scoped_allocator
 STD_HEADERS+=	semaphore
 STD_HEADERS+=	set
 STD_HEADERS+=	setjmp.h
 STD_HEADERS+=	shared_mutex
 STD_HEADERS+=	span
 STD_HEADERS+=	sstream
 STD_HEADERS+=	stack
 STD_HEADERS+=	stdbool.h
 STD_HEADERS+=	stddef.h
 STD_HEADERS+=	stdexcept
 STD_HEADERS+=	stdint.h
 STD_HEADERS+=	stdio.h
 STD_HEADERS+=	stdlib.h
 STD_HEADERS+=	streambuf
 STD_HEADERS+=	string
 STD_HEADERS+=	string.h
 STD_HEADERS+=	string_view
 STD_HEADERS+=	strstream
 STD_HEADERS+=	system_error
 STD_HEADERS+=	tgmath.h
 STD_HEADERS+=	thread
 STD_HEADERS+=	tuple
 STD_HEADERS+=	type_traits
 STD_HEADERS+=	typeindex
 STD_HEADERS+=	typeinfo
 STD_HEADERS+=	unordered_map
 STD_HEADERS+=	unordered_set
 STD_HEADERS+=	utility
 STD_HEADERS+=	valarray
 STD_HEADERS+=	variant
 STD_HEADERS+=	vector
 STD_HEADERS+=	version
 STD_HEADERS+=	wchar.h
 STD_HEADERS+=	wctype.h
 .for hdr in ${STD_HEADERS}
 STD+=		${HDRDIR}/${hdr}
 .endfor
 
 # Special case for __config_site, which as of libc++ 12.0.0 is generated by
 # CMake, and as of 13.0.0 installed side-by-side with__config.
 STD+=		${.CURDIR}/__config_site
 
 RT_HEADERS+=	cxxabi.h
 .for hdr in ${RT_HEADERS}
 STD+=		${_LIBCXXRTDIR}/${hdr}
 .endfor
 
 INCSGROUPS+=	ALG
 ALGDIR=		${CXXINCLUDEDIR}/__algorithm
 ALG_HEADERS+=	adjacent_find.h
 ALG_HEADERS+=	all_of.h
 ALG_HEADERS+=	any_of.h
 ALG_HEADERS+=	binary_search.h
 ALG_HEADERS+=	clamp.h
 ALG_HEADERS+=	comp.h
 ALG_HEADERS+=	comp_ref_type.h
 ALG_HEADERS+=	copy.h
 ALG_HEADERS+=	copy_backward.h
 ALG_HEADERS+=	copy_if.h
 ALG_HEADERS+=	copy_n.h
 ALG_HEADERS+=	count.h
 ALG_HEADERS+=	count_if.h
 ALG_HEADERS+=	equal.h
 ALG_HEADERS+=	equal_range.h
 ALG_HEADERS+=	fill.h
 ALG_HEADERS+=	fill_n.h
 ALG_HEADERS+=	find.h
 ALG_HEADERS+=	find_end.h
 ALG_HEADERS+=	find_first_of.h
 ALG_HEADERS+=	find_if.h
 ALG_HEADERS+=	find_if_not.h
 ALG_HEADERS+=	for_each.h
 ALG_HEADERS+=	for_each_n.h
 ALG_HEADERS+=	generate.h
 ALG_HEADERS+=	generate_n.h
 ALG_HEADERS+=	half_positive.h
 ALG_HEADERS+=	in_in_out_result.h
 ALG_HEADERS+=	in_in_result.h
 ALG_HEADERS+=	in_out_result.h
 ALG_HEADERS+=	includes.h
 ALG_HEADERS+=	inplace_merge.h
 ALG_HEADERS+=	is_heap.h
 ALG_HEADERS+=	is_heap_until.h
 ALG_HEADERS+=	is_partitioned.h
 ALG_HEADERS+=	is_permutation.h
 ALG_HEADERS+=	is_sorted.h
 ALG_HEADERS+=	is_sorted_until.h
 ALG_HEADERS+=	iter_swap.h
 ALG_HEADERS+=	lexicographical_compare.h
 ALG_HEADERS+=	lower_bound.h
 ALG_HEADERS+=	make_heap.h
 ALG_HEADERS+=	max.h
 ALG_HEADERS+=	max_element.h
 ALG_HEADERS+=	merge.h
 ALG_HEADERS+=	min.h
 ALG_HEADERS+=	min_element.h
 ALG_HEADERS+=	minmax.h
 ALG_HEADERS+=	minmax_element.h
 ALG_HEADERS+=	mismatch.h
 ALG_HEADERS+=	move.h
 ALG_HEADERS+=	move_backward.h
 ALG_HEADERS+=	next_permutation.h
 ALG_HEADERS+=	none_of.h
 ALG_HEADERS+=	nth_element.h
 ALG_HEADERS+=	partial_sort.h
 ALG_HEADERS+=	partial_sort_copy.h
 ALG_HEADERS+=	partition.h
 ALG_HEADERS+=	partition_copy.h
 ALG_HEADERS+=	partition_point.h
 ALG_HEADERS+=	pop_heap.h
 ALG_HEADERS+=	prev_permutation.h
 ALG_HEADERS+=	push_heap.h
 ALG_HEADERS+=	remove.h
 ALG_HEADERS+=	remove_copy.h
 ALG_HEADERS+=	remove_copy_if.h
 ALG_HEADERS+=	remove_if.h
 ALG_HEADERS+=	replace.h
 ALG_HEADERS+=	replace_copy.h
 ALG_HEADERS+=	replace_copy_if.h
 ALG_HEADERS+=	replace_if.h
 ALG_HEADERS+=	reverse.h
 ALG_HEADERS+=	reverse_copy.h
 ALG_HEADERS+=	rotate.h
 ALG_HEADERS+=	rotate_copy.h
 ALG_HEADERS+=	sample.h
 ALG_HEADERS+=	search.h
 ALG_HEADERS+=	search_n.h
 ALG_HEADERS+=	set_difference.h
 ALG_HEADERS+=	set_intersection.h
 ALG_HEADERS+=	set_symmetric_difference.h
 ALG_HEADERS+=	set_union.h
 ALG_HEADERS+=	shift_left.h
 ALG_HEADERS+=	shift_right.h
 ALG_HEADERS+=	shuffle.h
 ALG_HEADERS+=	sift_down.h
 ALG_HEADERS+=	sort.h
 ALG_HEADERS+=	sort_heap.h
 ALG_HEADERS+=	stable_partition.h
 ALG_HEADERS+=	stable_sort.h
 ALG_HEADERS+=	swap_ranges.h
 ALG_HEADERS+=	transform.h
 ALG_HEADERS+=	unique.h
 ALG_HEADERS+=	unique_copy.h
 ALG_HEADERS+=	unwrap_iter.h
 ALG_HEADERS+=	upper_bound.h
 .for hdr in ${ALG_HEADERS}
 ALG+=		${HDRDIR}/__algorithm/${hdr}
 .endfor
 
 INCSGROUPS+=	BIT
 BITDIR=		${CXXINCLUDEDIR}/__bit
 BIT_HEADERS+=	bit_cast.h
 BIT_HEADERS+=	byteswap.h
 .for hdr in ${BIT_HEADERS}
 BIT+=		${HDRDIR}/__bit/${hdr}
 .endfor
 
 INCSGROUPS+=	CHC
 CHCDIR=		${CXXINCLUDEDIR}/__charconv
 CHC_HEADERS+=	chars_format.h
 CHC_HEADERS+=	from_chars_result.h
 CHC_HEADERS+=	to_chars_result.h
 .for hdr in ${CHC_HEADERS}
 CHC+=		${HDRDIR}/__charconv/${hdr}
 .endfor
 
 INCSGROUPS+=	CHR
 CHRDIR=		${CXXINCLUDEDIR}/__chrono
 CHR_HEADERS+=	calendar.h
 CHR_HEADERS+=	convert_to_timespec.h
 CHR_HEADERS+=	duration.h
 CHR_HEADERS+=	file_clock.h
 CHR_HEADERS+=	high_resolution_clock.h
 CHR_HEADERS+=	steady_clock.h
 CHR_HEADERS+=	system_clock.h
 CHR_HEADERS+=	time_point.h
 .for hdr in ${CHR_HEADERS}
 CHR+=		${HDRDIR}/__chrono/${hdr}
 .endfor
 
 INCSGROUPS+=	CMP
 CMPDIR=		${CXXINCLUDEDIR}/__compare
 CMP_HEADERS+=	common_comparison_category.h
 CMP_HEADERS+=	compare_partial_order_fallback.h
 CMP_HEADERS+=	compare_strong_order_fallback.h
 CMP_HEADERS+=	compare_three_way.h
 CMP_HEADERS+=	compare_three_way_result.h
 CMP_HEADERS+=	compare_weak_order_fallback.h
 CMP_HEADERS+=	is_eq.h
 CMP_HEADERS+=	ordering.h
 CMP_HEADERS+=	partial_order.h
 CMP_HEADERS+=	strong_order.h
 CMP_HEADERS+=	synth_three_way.h
 CMP_HEADERS+=	three_way_comparable.h
 CMP_HEADERS+=	weak_order.h
 .for hdr in ${CMP_HEADERS}
 CMP+=		${HDRDIR}/__compare/${hdr}
 .endfor
 
 INCSGROUPS+=	CON
 CONDIR=		${CXXINCLUDEDIR}/__concepts
 CON_HEADERS+=	arithmetic.h
 CON_HEADERS+=	assignable.h
 CON_HEADERS+=	boolean_testable.h
 CON_HEADERS+=	class_or_enum.h
 CON_HEADERS+=	common_reference_with.h
 CON_HEADERS+=	common_with.h
 CON_HEADERS+=	constructible.h
 CON_HEADERS+=	convertible_to.h
 CON_HEADERS+=	copyable.h
 CON_HEADERS+=	derived_from.h
 CON_HEADERS+=	destructible.h
 CON_HEADERS+=	different_from.h
 CON_HEADERS+=	equality_comparable.h
 CON_HEADERS+=	invocable.h
 CON_HEADERS+=	movable.h
 CON_HEADERS+=	predicate.h
 CON_HEADERS+=	regular.h
 CON_HEADERS+=	relation.h
 CON_HEADERS+=	same_as.h
 CON_HEADERS+=	semiregular.h
 CON_HEADERS+=	swappable.h
 CON_HEADERS+=	totally_ordered.h
 .for hdr in ${CON_HEADERS}
 CON+=		${HDRDIR}/__concepts/${hdr}
 .endfor
 
 INCSGROUPS+=	COR
 CORDIR=		${CXXINCLUDEDIR}/__coroutine
 COR_HEADERS+=	coroutine_handle.h
 COR_HEADERS+=	coroutine_traits.h
 COR_HEADERS+=	noop_coroutine_handle.h
 COR_HEADERS+=	trivial_awaitables.h
 .for hdr in ${COR_HEADERS}
 COR+=		${HDRDIR}/__coroutine/${hdr}
 .endfor
 
 INCSGROUPS+=	FS
 FSDIR=		${CXXINCLUDEDIR}/__filesystem
 FS_HEADERS+=	copy_options.h
 FS_HEADERS+=	directory_entry.h
 FS_HEADERS+=	directory_iterator.h
 FS_HEADERS+=	directory_options.h
 FS_HEADERS+=	file_status.h
 FS_HEADERS+=	file_time_type.h
 FS_HEADERS+=	file_type.h
 FS_HEADERS+=	filesystem_error.h
 FS_HEADERS+=	operations.h
 FS_HEADERS+=	path.h
 FS_HEADERS+=	path_iterator.h
 FS_HEADERS+=	perm_options.h
 FS_HEADERS+=	perms.h
 FS_HEADERS+=	recursive_directory_iterator.h
 FS_HEADERS+=	space_info.h
 FS_HEADERS+=	u8path.h
 .for hdr in ${FS_HEADERS}
 FS+=		${HDRDIR}/__filesystem/${hdr}
 .endfor
 
 INCSGROUPS+=	FMT
 FMTDIR=		${CXXINCLUDEDIR}/__format
 FMT_HEADERS+=	format_arg.h
 FMT_HEADERS+=	format_args.h
 FMT_HEADERS+=	format_context.h
 FMT_HEADERS+=	format_error.h
 FMT_HEADERS+=	format_fwd.h
 FMT_HEADERS+=	format_parse_context.h
 FMT_HEADERS+=	format_string.h
 FMT_HEADERS+=	format_to_n_result.h
 FMT_HEADERS+=	formatter.h
 FMT_HEADERS+=	formatter_bool.h
 FMT_HEADERS+=	formatter_char.h
 FMT_HEADERS+=	formatter_floating_point.h
 FMT_HEADERS+=	formatter_integer.h
 FMT_HEADERS+=	formatter_integral.h
 FMT_HEADERS+=	formatter_pointer.h
 FMT_HEADERS+=	formatter_string.h
 FMT_HEADERS+=	parser_std_format_spec.h
 .for hdr in ${FMT_HEADERS}
 FMT+=		${HDRDIR}/__format/${hdr}
 .endfor
 
 INCSGROUPS+=	FUN
 FUNDIR=		${CXXINCLUDEDIR}/__functional
 FUN_HEADERS+=	binary_function.h
 FUN_HEADERS+=	binary_negate.h
 FUN_HEADERS+=	bind.h
 FUN_HEADERS+=	bind_back.h
 FUN_HEADERS+=	bind_front.h
 FUN_HEADERS+=	binder1st.h
 FUN_HEADERS+=	binder2nd.h
 FUN_HEADERS+=	compose.h
 FUN_HEADERS+=	default_searcher.h
 FUN_HEADERS+=	function.h
 FUN_HEADERS+=	hash.h
 FUN_HEADERS+=	identity.h
 FUN_HEADERS+=	invoke.h
 FUN_HEADERS+=	is_transparent.h
 FUN_HEADERS+=	mem_fn.h
 FUN_HEADERS+=	mem_fun_ref.h
 FUN_HEADERS+=	not_fn.h
 FUN_HEADERS+=	operations.h
 FUN_HEADERS+=	perfect_forward.h
 FUN_HEADERS+=	pointer_to_binary_function.h
 FUN_HEADERS+=	pointer_to_unary_function.h
 FUN_HEADERS+=	ranges_operations.h
 FUN_HEADERS+=	reference_wrapper.h
 FUN_HEADERS+=	unary_function.h
 FUN_HEADERS+=	unary_negate.h
 FUN_HEADERS+=	unwrap_ref.h
 FUN_HEADERS+=	weak_result_type.h
 .for hdr in ${FUN_HEADERS}
 FUN+=		${HDRDIR}/__functional/${hdr}
 .endfor
 
 INCSGROUPS+=	IT
 ITDIR=		${CXXINCLUDEDIR}/__iterator
 IT_HEADERS+=	access.h
 IT_HEADERS+=	advance.h
 IT_HEADERS+=	back_insert_iterator.h
 IT_HEADERS+=	common_iterator.h
 IT_HEADERS+=	concepts.h
 IT_HEADERS+=	counted_iterator.h
 IT_HEADERS+=	data.h
 IT_HEADERS+=	default_sentinel.h
 IT_HEADERS+=	distance.h
 IT_HEADERS+=	empty.h
 IT_HEADERS+=	erase_if_container.h
 IT_HEADERS+=	front_insert_iterator.h
 IT_HEADERS+=	incrementable_traits.h
 IT_HEADERS+=	indirectly_comparable.h
 IT_HEADERS+=	insert_iterator.h
 IT_HEADERS+=	istream_iterator.h
 IT_HEADERS+=	istreambuf_iterator.h
 IT_HEADERS+=	iter_move.h
 IT_HEADERS+=	iter_swap.h
 IT_HEADERS+=	iterator.h
 IT_HEADERS+=	iterator_traits.h
 IT_HEADERS+=	move_iterator.h
 IT_HEADERS+=	next.h
 IT_HEADERS+=	ostream_iterator.h
 IT_HEADERS+=	ostreambuf_iterator.h
 IT_HEADERS+=	prev.h
 IT_HEADERS+=	projected.h
 IT_HEADERS+=	readable_traits.h
 IT_HEADERS+=	reverse_access.h
 IT_HEADERS+=	reverse_iterator.h
 IT_HEADERS+=	size.h
 IT_HEADERS+=	unreachable_sentinel.h
 IT_HEADERS+=	wrap_iter.h
 .for hdr in ${IT_HEADERS}
 IT+=		${HDRDIR}/__iterator/${hdr}
 .endfor
 
 INCSGROUPS+=	MEM
 MEMDIR=		${CXXINCLUDEDIR}/__memory
 MEM_HEADERS+=	addressof.h
 MEM_HEADERS+=	allocation_guard.h
 MEM_HEADERS+=	allocator.h
 MEM_HEADERS+=	allocator_arg_t.h
 MEM_HEADERS+=	allocator_traits.h
 MEM_HEADERS+=	auto_ptr.h
 MEM_HEADERS+=	compressed_pair.h
 MEM_HEADERS+=	concepts.h
 MEM_HEADERS+=	construct_at.h
 MEM_HEADERS+=	pointer_traits.h
 MEM_HEADERS+=	ranges_construct_at.h
 MEM_HEADERS+=	ranges_uninitialized_algorithms.h
 MEM_HEADERS+=	raw_storage_iterator.h
 MEM_HEADERS+=	shared_ptr.h
 MEM_HEADERS+=	temporary_buffer.h
 MEM_HEADERS+=	uninitialized_algorithms.h
 MEM_HEADERS+=	unique_ptr.h
 MEM_HEADERS+=	uses_allocator.h
 MEM_HEADERS+=	voidify.h
 .for hdr in ${MEM_HEADERS}
 MEM+=		${HDRDIR}/__memory/${hdr}
 .endfor
 
 INCSGROUPS+=    NUM
 NUMDIR=		${CXXINCLUDEDIR}/__numeric
 NUM_HEADERS+=	accumulate.h
 NUM_HEADERS+=	adjacent_difference.h
 NUM_HEADERS+=	exclusive_scan.h
 NUM_HEADERS+=	gcd_lcm.h
 NUM_HEADERS+=	inclusive_scan.h
 NUM_HEADERS+=	inner_product.h
 NUM_HEADERS+=	iota.h
 NUM_HEADERS+=	midpoint.h
 NUM_HEADERS+=	partial_sum.h
 NUM_HEADERS+=	reduce.h
 NUM_HEADERS+=	transform_exclusive_scan.h
 NUM_HEADERS+=	transform_inclusive_scan.h
 NUM_HEADERS+=	transform_reduce.h
 .for hdr in ${NUM_HEADERS}
 NUM+=		${HDRDIR}/__numeric/${hdr}
 .endfor
 
 INCSGROUPS+=	RND
 RNDDIR=		${CXXINCLUDEDIR}/__random
 RND_HEADERS+=	bernoulli_distribution.h
 RND_HEADERS+=	binomial_distribution.h
 RND_HEADERS+=	cauchy_distribution.h
 RND_HEADERS+=	chi_squared_distribution.h
 RND_HEADERS+=	clamp_to_integral.h
 RND_HEADERS+=	default_random_engine.h
 RND_HEADERS+=	discard_block_engine.h
 RND_HEADERS+=	discrete_distribution.h
 RND_HEADERS+=	exponential_distribution.h
 RND_HEADERS+=	extreme_value_distribution.h
 RND_HEADERS+=	fisher_f_distribution.h
 RND_HEADERS+=	gamma_distribution.h
 RND_HEADERS+=	generate_canonical.h
 RND_HEADERS+=	geometric_distribution.h
 RND_HEADERS+=	independent_bits_engine.h
 RND_HEADERS+=	is_seed_sequence.h
 RND_HEADERS+=	knuth_b.h
 RND_HEADERS+=	linear_congruential_engine.h
 RND_HEADERS+=	log2.h
 RND_HEADERS+=	lognormal_distribution.h
 RND_HEADERS+=	mersenne_twister_engine.h
 RND_HEADERS+=	negative_binomial_distribution.h
 RND_HEADERS+=	normal_distribution.h
 RND_HEADERS+=	piecewise_constant_distribution.h
 RND_HEADERS+=	piecewise_linear_distribution.h
 RND_HEADERS+=	poisson_distribution.h
 RND_HEADERS+=	random_device.h
 RND_HEADERS+=	ranlux.h
 RND_HEADERS+=	seed_seq.h
 RND_HEADERS+=	shuffle_order_engine.h
 RND_HEADERS+=	student_t_distribution.h
 RND_HEADERS+=	subtract_with_carry_engine.h
 RND_HEADERS+=	uniform_int_distribution.h
 RND_HEADERS+=	uniform_random_bit_generator.h
 RND_HEADERS+=	uniform_real_distribution.h
 RND_HEADERS+=	weibull_distribution.h
 .for hdr in ${RND_HEADERS}
 RND+=		${HDRDIR}/__random/${hdr}
 .endfor
 
 INCSGROUPS+=	RNG
 RNGDIR=		${CXXINCLUDEDIR}/__ranges
 RNG_HEADERS+=	access.h
 RNG_HEADERS+=	all.h
 RNG_HEADERS+=	common_view.h
 RNG_HEADERS+=	concepts.h
 RNG_HEADERS+=	copyable_box.h
 RNG_HEADERS+=	counted.h
 RNG_HEADERS+=	dangling.h
 RNG_HEADERS+=	data.h
 RNG_HEADERS+=	drop_view.h
 RNG_HEADERS+=	empty.h
 RNG_HEADERS+=	empty_view.h
 RNG_HEADERS+=	enable_borrowed_range.h
 RNG_HEADERS+=	enable_view.h
 RNG_HEADERS+=	iota_view.h
 RNG_HEADERS+=	join_view.h
 RNG_HEADERS+=	non_propagating_cache.h
 RNG_HEADERS+=	owning_view.h
 RNG_HEADERS+=	range_adaptor.h
 RNG_HEADERS+=	ref_view.h
 RNG_HEADERS+=	reverse_view.h
 RNG_HEADERS+=	single_view.h
 RNG_HEADERS+=	size.h
 RNG_HEADERS+=	subrange.h
 RNG_HEADERS+=	take_view.h
 RNG_HEADERS+=	transform_view.h
 RNG_HEADERS+=	view_interface.h
+RNG_HEADERS+=	views.h
 .for hdr in ${RNG_HEADERS}
 RNG+=		${HDRDIR}/__ranges/${hdr}
 .endfor
 
 INCSGROUPS+=	THR
 THRDIR=		${CXXINCLUDEDIR}/__thread
 THR_HEADERS+=	poll_with_backoff.h
 THR_HEADERS+=	timed_backoff_policy.h
 .for hdr in ${THR_HEADERS}
 THR+=		${HDRDIR}/__thread/${hdr}
 .endfor
 
 INCSGROUPS+=	UTL
 UTLDIR=		${CXXINCLUDEDIR}/__utility
 UTL_HEADERS+=	as_const.h
 UTL_HEADERS+=	auto_cast.h
 UTL_HEADERS+=	cmp.h
 UTL_HEADERS+=	declval.h
 UTL_HEADERS+=	exchange.h
 UTL_HEADERS+=	forward.h
 UTL_HEADERS+=	in_place.h
 UTL_HEADERS+=	integer_sequence.h
 UTL_HEADERS+=	move.h
 UTL_HEADERS+=	pair.h
 UTL_HEADERS+=	piecewise_construct.h
 UTL_HEADERS+=	priority_tag.h
 UTL_HEADERS+=	rel_ops.h
 UTL_HEADERS+=	swap.h
 UTL_HEADERS+=	to_underlying.h
 UTL_HEADERS+=	transaction.h
 .for hdr in ${UTL_HEADERS}
 UTL+=		${HDRDIR}/__utility/${hdr}
 .endfor
 
 INCSGROUPS+=	VAR
 VARDIR=	${CXXINCLUDEDIR}/__variant
 VAR_HEADERS+=	monostate.h
 .for hdr in ${VAR_HEADERS}
 VAR+=		${HDRDIR}/__variant/${hdr}
 .endfor
 
 INCSGROUPS+=	EXP
 EXPDIR=		${CXXINCLUDEDIR}/experimental
 EXP_HEADERS+=	__config
 EXP_HEADERS+=	__memory
 EXP_HEADERS+=	algorithm
 EXP_HEADERS+=	coroutine
 EXP_HEADERS+=	deque
 EXP_HEADERS+=	filesystem
 EXP_HEADERS+=	forward_list
 EXP_HEADERS+=	functional
 EXP_HEADERS+=	iterator
 EXP_HEADERS+=	list
 EXP_HEADERS+=	map
 EXP_HEADERS+=	memory_resource
 EXP_HEADERS+=	propagate_const
 EXP_HEADERS+=	regex
 EXP_HEADERS+=	set
 EXP_HEADERS+=	simd
 EXP_HEADERS+=	string
 EXP_HEADERS+=	type_traits
 EXP_HEADERS+=	unordered_map
 EXP_HEADERS+=	unordered_set
 EXP_HEADERS+=	utility
 EXP_HEADERS+=	vector
 .for hdr in ${EXP_HEADERS}
 EXP+=		${HDRDIR}/experimental/${hdr}
 .endfor
 
 INCSGROUPS+=	EXT
 EXTDIR=		${CXXINCLUDEDIR}/ext
 EXT_HEADERS+=	__hash
 EXT_HEADERS+=	hash_map
 EXT_HEADERS+=	hash_set
 .for hdr in ${EXT_HEADERS}
 EXT+=		${HDRDIR}/ext/${hdr}
 .endfor
 
 .include <bsd.lib.mk>