diff --git a/source/containers.tex b/source/containers.tex
index 92809c8481..5f413da14f 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -20532,7 +20532,7 @@
 
 \pnum
 \effects
-Initializes \exposid{data_} with \tcode{il.begin()} and
+Initializes \exposid{data_} with \tcode{il.data()} and
 \exposid{size_} with \tcode{il.size()}.
 \end{itemdescr}
 
diff --git a/source/iterators.tex b/source/iterators.tex
index 9914bd249f..899c88fabf 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -33,6 +33,7 @@
 \begin{codeblock}
 #include <compare>              // see \ref{compare.syn}
 #include <concepts>             // see \ref{concepts.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   template<class T> using @\exposid{with-reference}@ = T&;  // \expos
@@ -464,53 +465,64 @@
     class ostreambuf_iterator;
 
   // \ref{iterator.range}, range access
-  template<class C> constexpr auto begin(C& c) -> decltype(c.begin());              // freestanding
-  template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());        // freestanding
-  template<class C> constexpr auto end(C& c) -> decltype(c.end());                  // freestanding
-  template<class C> constexpr auto end(const C& c) -> decltype(c.end());            // freestanding
+  template<class C> constexpr auto
+    begin(C& c) noexcept(noexcept(c.begin())) -> decltype(c.begin());               // freestanding
+  template<class C> constexpr auto
+    begin(const C& c) noexcept(noexcept(c.begin())) -> decltype(c.begin());         // freestanding
+  template<class C> constexpr auto
+    end(C& c) noexcept(noexcept(c.end())) -> decltype(c.end());                     // freestanding
+  template<class C> constexpr auto
+    end(const C& c) noexcept(noexcept(c.end())) -> decltype(c.end());               // freestanding
   template<class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;           // freestanding
   template<class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;             // freestanding
-  template<class C> constexpr auto cbegin(const C& c)                               // freestanding
-    noexcept(noexcept(std::begin(c))) -> decltype(std::begin(c));
-  template<class C> constexpr auto cend(const C& c)                                 // freestanding
-    noexcept(noexcept(std::end(c))) -> decltype(std::end(c));
-  template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());            // freestanding
-  template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());      // freestanding
-  template<class C> constexpr auto rend(C& c) -> decltype(c.rend());                // freestanding
-  template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());          // freestanding
-  template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N])  // freestanding
-  template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);   // freestanding
+  template<class C> constexpr auto
+    cbegin(const C& c) noexcept(noexcept(std::begin(c)))
+      -> decltype(std::begin(c));                                                   // freestanding
+  template<class C> constexpr auto
+    cend(const C& c) noexcept(noexcept(std::end(c))) -> decltype(std::end(c));      // freestanding
+  template<class C> constexpr auto
+    rbegin(C& c) noexcept(noexcept(c.rbegin())) -> decltype(c.rbegin());            // freestanding
+  template<class C> constexpr auto
+    rbegin(const C& c) noexcept(noexcept(c.rbegin())) -> decltype(c.rbegin());      // freestanding
+  template<class C> constexpr auto
+    rend(C& c) noexcept(noexcept(c.rend())) -> decltype(c.rend());                  // freestanding
+  template<class C> constexpr auto
+    rend(const C& c) noexcept(noexcept(c.rend())) -> decltype(c.rend());            // freestanding
+  template<class T, size_t N> constexpr reverse_iterator<T*>
+    rbegin(T (&array)[N]) noexcept;                                                 // freestanding
+  template<class T, size_t N> constexpr reverse_iterator<T*>
+    rend(T (&array)[N]) noexcept;                                                   // freestanding
   template<class E> constexpr reverse_iterator<const E*>
-    rbegin(initializer_list<E> il);                                                 // freestanding
+    rbegin(initializer_list<E> il) noexcept;                                        // freestanding
   template<class E> constexpr reverse_iterator<const E*>
-    rend(initializer_list<E> il);                                                   // freestanding
+    rend(initializer_list<E> il) noexcept;                                          // freestanding
   template<class C> constexpr auto
-    crbegin(const C& c) -> decltype(std::rbegin(c));                                // freestanding
+    crbegin(const C& c) noexcept(noexcept(std::rbegin(c)))
+      -> decltype(std::rbegin(c));                                                  // freestanding
   template<class C> constexpr auto
-    crend(const C& c) -> decltype(std::rend(c));                                    // freestanding
+    crend(const C& c) noexcept(noexcept(std::rend(c))) -> decltype(std::rend(c));   // freestanding
 
   template<class C> constexpr auto
-    size(const C& c) -> decltype(c.size());                                         // freestanding
+    size(const C& c) noexcept(noexcept(c.size())) -> decltype(c.size());            // freestanding
   template<class T, size_t N> constexpr size_t
     size(const T (&array)[N]) noexcept;                                             // freestanding
 
   template<class C> constexpr auto
-    ssize(const C& c)
+    ssize(const C& c) noexcept(noexcept(c.size()))
       -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;               // freestanding
   template<class T, ptrdiff_t N> constexpr ptrdiff_t
     ssize(const T (&array)[N]) noexcept;                                            // freestanding
 
   template<class C> constexpr auto
-    empty(const C& c) -> decltype(c.empty());                                       // freestanding
+    empty(const C& c) noexcept(noexcept(c.empty())) -> decltype(c.empty());         // freestanding
   template<class T, size_t N> constexpr bool
     empty(const T (&array)[N]) noexcept;                                            // freestanding
-  template<class E> constexpr bool
-    empty(initializer_list<E> il) noexcept;                                         // freestanding
 
-  template<class C> constexpr auto data(C& c) -> decltype(c.data());                // freestanding
-  template<class C> constexpr auto data(const C& c) -> decltype(c.data());          // freestanding
+  template<class C> constexpr auto
+    data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data());                  // freestanding
+  template<class C> constexpr auto
+    data(const C& c) noexcept(noexcept(c.data())) -> decltype(c.data());            // freestanding
   template<class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;            // freestanding
-  template<class E> constexpr const E* data(initializer_list<E> il) noexcept;       // freestanding
 }
 \end{codeblock}
 
@@ -7241,28 +7253,38 @@
 In addition to being available via inclusion of the \libheader{iterator} header,
 the function templates in \ref{iterator.range} are available when any of the following
 headers are included:
-\libheaderref{array},
-\libheaderref{deque},
-\libheaderrefx{flat_map}{flat.map.syn},
-\libheaderrefx{flat_set}{flat.set.syn},
-\libheaderrefx{forward_list}{forward.list.syn},
-\libheaderref{hive},
-\libheaderrefx{inplace_vector}{inplace.vector.syn},
-\libheaderref{list},
-\libheaderrefx{map}{associative.map.syn},
-\libheaderrefx{regex}{re.syn},
-\libheaderrefx{set}{associative.set.syn},
-\libheaderref{span},
-\libheaderref{string},
-\libheaderrefx{string_view}{string.view.synop},
-\libheaderrefx{unordered_map}{unord.map.syn},
-\libheaderrefx{unordered_set}{unord.set.syn}, and
-\libheaderref{vector}.
+\begin{multicolfloattable}{Additional range function headers}{range.function.headers}
+{lll}
+\libheaderref{array} \\
+\libheaderref{deque} \\
+\libheaderrefx{flat_map}{flat.map.syn} \\
+\libheaderrefx{flat_set}{flat.set.syn} \\
+\libheaderrefx{forward_list}{forward.list.syn} \\
+\libheaderref{hive} \\
+\libheaderrefx{inplace_vector}{inplace.vector.syn} \\
+\columnbreak
+\libheaderref{list} \\
+\libheaderrefx{map}{associative.map.syn} \\
+\libheaderref{optional} \\
+\libheaderrefx{regex}{re.syn} \\
+\libheaderrefx{set}{associative.set.syn} \\
+\libheaderref{span} \\
+\libheaderref{stacktrace} \\
+\columnbreak
+\libheaderref{string} \\
+\libheaderrefx{string_view}{string.view.synop} \\
+\libheaderrefx{unordered_map}{unord.map.syn} \\
+\libheaderrefx{unordered_set}{unord.set.syn} \\
+\libheaderref{valarray} \\
+\libheaderref{vector} \\
+\end{multicolfloattable}
 
 \indexlibrary{\idxcode{begin(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
-template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
+template<class C> constexpr auto begin(C& c) noexcept(noexcept(c.begin()))
+  -> decltype(c.begin());
+template<class C> constexpr auto begin(const C& c) noexcept(noexcept(c.begin()))
+  -> decltype(c.begin());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -7273,8 +7295,8 @@
 
 \indexlibrary{\idxcode{end(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto end(C& c) -> decltype(c.end());
-template<class C> constexpr auto end(const C& c) -> decltype(c.end());
+template<class C> constexpr auto end(C& c) noexcept(noexcept(c.end())) -> decltype(c.end());
+template<class C> constexpr auto end(const C& c) noexcept(noexcept(c.end())) -> decltype(c.end());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -7329,8 +7351,10 @@
 
 \indexlibrary{\idxcode{rbegin(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
-template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
+template<class C> constexpr auto rbegin(C& c) noexcept(noexcept(c.rbegin()))
+  -> decltype(c.rbegin());
+template<class C> constexpr auto rbegin(const C& c) noexcept(noexcept(c.rbegin()))
+  -> decltype(c.rbegin());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7340,8 +7364,9 @@
 
 \indexlibrary{\idxcode{rend(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto rend(C& c) -> decltype(c.rend());
-template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());
+template<class C> constexpr auto rend(C& c) noexcept(noexcept(c.rend())) -> decltype(c.rend());
+template<class C> constexpr auto rend(const C& c) noexcept(noexcept(c.rend()))
+  -> decltype(c.rend());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7351,7 +7376,7 @@
 
 \indexlibrary{\idxcode{rbegin(T (\&array)[N])}}%
 \begin{itemdecl}
-template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]);
+template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7361,7 +7386,7 @@
 
 \indexlibrary{\idxcode{rend(T (\&array)[N])}}%
 \begin{itemdecl}
-template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);
+template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7371,7 +7396,7 @@
 
 \indexlibrary{\idxcode{rbegin(initializer_list<E>)}}%
 \begin{itemdecl}
-template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
+template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7381,7 +7406,7 @@
 
 \indexlibrary{\idxcode{rend(initializer_list<E>)}}%
 \begin{itemdecl}
-template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);
+template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7391,7 +7416,8 @@
 
 \indexlibrary{\idxcode{crbegin(const C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
+template<class C> constexpr auto crbegin(const C& c) noexcept(noexcept(c.crbegin()))
+  -> decltype(std::rbegin(c));
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7401,7 +7427,8 @@
 
 \indexlibrary{\idxcode{crend(const C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
+template<class C> constexpr auto crend(const C& c) noexcept(noexcept(c.crend()))
+  -> decltype(std::rend(c));
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7411,7 +7438,8 @@
 
 \indexlibrary{\idxcode{size(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto size(const C& c) -> decltype(c.size());
+template<class C> constexpr auto size(const C& c) noexcept(noexcept(c.size()))
+  -> decltype(c.size());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7431,7 +7459,7 @@
 
 \indexlibrary{\idxcode{ssize(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto ssize(const C& c)
+template<class C> constexpr auto ssize(const C& c) noexcept(noexcept(c.ssize()))
   -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;
 \end{itemdecl}
 \begin{itemdescr}
@@ -7455,7 +7483,8 @@
 
 \indexlibrary{\idxcode{empty(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto empty(const C& c) -> decltype(c.empty());
+template<class C> constexpr auto empty(const C& c) noexcept(noexcept(c.empty()))
+  -> decltype(c.empty());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7473,20 +7502,11 @@
 \tcode{false}.
 \end{itemdescr}
 
-\indexlibrary{\idxcode{empty(initializer_list<E>)}}%
-\begin{itemdecl}
-template<class E> constexpr bool empty(initializer_list<E> il) noexcept;
-\end{itemdecl}
-\begin{itemdescr}
-\pnum
-\returns
-\tcode{il.size() == 0}.
-\end{itemdescr}
-
 \indexlibrary{\idxcode{data(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto data(C& c) -> decltype(c.data());
-template<class C> constexpr auto data(const C& c) -> decltype(c.data());
+template<class C> constexpr auto data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data());
+template<class C> constexpr auto data(const C& c) noexcept(noexcept(c.data()))
+  -> decltype(c.data());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7503,13 +7523,3 @@
 \returns
 \tcode{array}.
 \end{itemdescr}
-
-\indexlibrary{\idxcode{data(initializer_list<E>)}}%
-\begin{itemdecl}
-template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
-\end{itemdecl}
-\begin{itemdescr}
-\pnum
-\returns
-\tcode{il.begin()}.
-\end{itemdescr}
diff --git a/source/numerics.tex b/source/numerics.tex
index c4310e62fb..d918cd55a4 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -7120,11 +7120,6 @@
   template<class T> valarray<T> sqrt (const valarray<T>&);
   template<class T> valarray<T> tan  (const valarray<T>&);
   template<class T> valarray<T> tanh (const valarray<T>&);
-
-  template<class T> @\unspec{1}@ begin(valarray<T>& v);
-  template<class T> @\unspec{2}@ begin(const valarray<T>& v);
-  template<class T> @\unspec{1}@ end(valarray<T>& v);
-  template<class T> @\unspec{2}@ end(const valarray<T>& v);
 }
 \end{codeblock}
 
@@ -7157,6 +7152,7 @@
 is permitted to return an object of another type, provided all the
 const member functions of
 \tcode{valarray<T>}
+other than \tcode{begin} and \tcode{end}
 are also applicable to this type.
 This return type shall not add
 more than two levels of template nesting over the most deeply nested
@@ -7175,8 +7171,7 @@
 \begin{itemize}
 \item
 for every function taking a
-\tcode{const valarray<T>\&} other than \tcode{begin} and
-\tcode{end}\iref{valarray.range},
+\tcode{const valarray<T>\&},
 identical functions taking the replacement types shall be added;
 \item
 for every function taking two
@@ -7214,7 +7209,10 @@
 namespace std {
   template<class T> class valarray {
   public:
-    using value_type = T;
+    using value_type        = T;
+    using iterator          = @\unspec@;
+    using const_iterator    = @\unspec@;
+
 
     // \ref{valarray.cons}, construct/destroy
     valarray();
@@ -7283,6 +7281,12 @@
     valarray& operator<<=(const valarray&);
     valarray& operator>>=(const valarray&);
 
+    // \ref{valarray.range}, range access
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
+
     // \ref{valarray.members}, member functions
     void swap(valarray&) noexcept;
 
@@ -7447,7 +7451,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to \tcode{valarray(il.begin(), il.size())}.
+Equivalent to \tcode{valarray(il.data(), il.size())}.
 \end{itemdescr}
 
 \indexlibraryctor{valarray}%
@@ -9154,20 +9158,20 @@
 object refers.
 \end{itemdescr}
 
-\rSec2[valarray.range]{\tcode{valarray} range access}
+\rSec2[valarray.range]{range access}
 
 \pnum
-In the \tcode{begin} and \tcode{end} function templates that follow, \unspec{1}
+The \tcode{iterator} type
 is a type that meets the requirements of a mutable
 \oldconcept{RandomAccessIterator}\iref{random.access.iterators}
-and models \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
-whose \tcode{value_type} is the template
-parameter \tcode{T} and whose \tcode{reference} type is \tcode{T\&}. \unspec{2} is a
-type that meets the requirements of a constant
+and models \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous}.
+Its \tcode{value_type} is the template
+parameter \tcode{T} and its \tcode{reference} type is \tcode{T\&}.
+The \tcode{const_iterator} type meets the requirements of a constant
 \oldconcept{RandomAccessIterator}
-and models \libconcept{contiguous_iterator},
-whose \tcode{value_type} is the template
-parameter \tcode{T} and whose \tcode{reference} type is \tcode{const T\&}.
+and models \libconcept{contiguous_iterator}.
+Its \tcode{value_type} is the template
+parameter \tcode{T} and its \tcode{reference} type is \tcode{const T\&}.
 
 \pnum
 The iterators returned by \tcode{begin} and \tcode{end} for an array
@@ -9176,10 +9180,10 @@
 array or until the lifetime of that array ends, whichever happens
 first.
 
-\indexlibrarymember{begin}{valarray}%
+\indexlibrarymember{valarray}{begin}%
 \begin{itemdecl}
-template<class T> @\unspec{1}@ begin(valarray<T>& v);
-template<class T> @\unspec{2}@ begin(const valarray<T>& v);
+iterator begin();
+const_iterator begin() const;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -9188,10 +9192,10 @@
 An iterator referencing the first value in the array.
 \end{itemdescr}
 
-\indexlibrarymember{end}{valarray}%
+\indexlibrarymember{valarray}{end}%
 \begin{itemdecl}
-template<class T> @\unspec{1}@ end(valarray<T>& v);
-template<class T> @\unspec{2}@ end(const valarray<T>& v);
+iterator end();
+const_iterator end() const;
 \end{itemdecl}
 
 \begin{itemdescr}
diff --git a/source/strings.tex b/source/strings.tex
index 9e1e9481b8..a9a64f7f96 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -3406,7 +3406,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to: \tcode{return append(il.begin(), il.size());}
+Equivalent to: \tcode{return append(il.data(), il.size());}
 \end{itemdescr}
 
 \indexlibrarymember{push_back}{basic_string}%
@@ -3555,7 +3555,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to: \tcode{return assign(il.begin(), il.size());}
+Equivalent to: \tcode{return assign(il.data(), il.size());}
 \end{itemdescr}
 
 \indexlibrarymember{assign}{basic_string}%
@@ -4230,7 +4230,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to: \tcode{return replace(i1, i2, il.begin(), il.size());}
+Equivalent to: \tcode{return replace(i1, i2, il.data(), il.size());}
 \end{itemdescr}
 
 \rSec4[string.copy]{\tcode{basic_string::copy}}
diff --git a/source/support.tex b/source/support.tex
index c6929d58ff..ad08cd04e7 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -578,7 +578,8 @@
   // freestanding, also in \libheader{memory}, \libheader{scoped_allocator}, \libheader{string}, \libheader{deque}, \libheader{forward_list}, \libheader{list},
   // \libheader{vector}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}
 #define @\defnlibxname{cpp_lib_any}@                               201606L // also in \libheader{any}
-#define @\defnlibxname{cpp_lib_apply}@                             202506L // freestanding, also in \libheader{tuple}, \libheader{type_traits}
+#define @\defnlibxname{cpp_lib_apply}@                             202506L
+  // freestanding, also in \libheader{tuple}, \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_array_constexpr}@                   201811L // also in \libheader{iterator}, \libheader{array}
 #define @\defnlibxname{cpp_lib_as_const}@                          201510L // freestanding, also in \libheader{utility}
 #define @\defnlibxname{cpp_lib_associative_heterogeneous_erasure}@ 202110L
@@ -723,6 +724,8 @@
   // also in \libheader{forward_list}, \libheader{list}, \libheader{vector}
 #define @\defnlibxname{cpp_lib_indirect}@                          202502L // also in \libheader{memory}
 #define @\defnlibxname{cpp_lib_inplace_vector}@                    202406L // also in \libheader{inplace_vector}
+#define @\defnlibxname{cpp_lib_initializer_list}@                  202511L
+  // freestanding, also in \libheader{initializer_list}
 #define @\defnlibxname{cpp_lib_int_pow2}@                          202002L // freestanding, also in \libheader{bit}
 #define @\defnlibxname{cpp_lib_integer_comparison_functions}@      202002L // also in \libheader{utility}
 #define @\defnlibxname{cpp_lib_integer_sequence}@                  201304L // freestanding, also in \libheader{utility}
@@ -873,6 +876,7 @@
 #define @\defnlibxname{cpp_lib_unordered_map_try_emplace}@         201411L // also in \libheader{unordered_map}
 #define @\defnlibxname{cpp_lib_unreachable}@                       202202L // freestanding, also in \libheader{utility}
 #define @\defnlibxname{cpp_lib_unwrap_ref}@                        201811L // freestanding, also in \libheader{type_traits}
+#define @\defnlibxname{cpp_lib_valarray}@                          202511L // also in \libheader{valarray}
 #define @\defnlibxname{cpp_lib_variant}@                           202306L // also in \libheader{variant}
 #define @\defnlibxname{cpp_lib_void_t}@                            201411L // freestanding, also in \libheader{type_traits}
 \end{codeblock}
@@ -3469,6 +3473,7 @@
 \indexheader{typeindex}%
 \begin{codeblock}
 #include <compare>              // see \ref{compare.syn}
+#include <typeinfo>             // see \ref{typeinfo.syn}
 
 namespace std {
   class type_index;
@@ -4682,14 +4687,12 @@
 
     constexpr initializer_list() noexcept;
 
+    constexpr const E* data() const noexcept;
     constexpr size_t size() const noexcept;     // number of elements
+    constexpr bool empty() const noexcept;
     constexpr const E* begin() const noexcept;  // first element
     constexpr const E* end() const noexcept;    // one past the last element
   };
-
-  // \ref{support.initlist.range}, initializer list range access
-  template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
-  template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
 }
 \end{codeblock}
 
@@ -4747,43 +4750,41 @@
 \tcode{begin() + size()}.
 \end{itemdescr}
 
-\indexlibrarymember{size}{initializer_list}%
+\indexlibrarymember{data}{initializer_list}%
 \begin{itemdecl}
-constexpr size_t size() const noexcept;
+constexpr const E* data() const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \returns
-The number of elements in the array.
-
-\pnum
-\complexity
-Constant time.
+\tcode{begin()}.
 \end{itemdescr}
 
-\rSec2[support.initlist.range]{Initializer list range access}
-
-\indexlibrary{\idxcode{begin(initializer_list<E>)}}%
+\indexlibrarymember{size}{initializer_list}%
 \begin{itemdecl}
-template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
+constexpr size_t size() const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{il.begin()}.
+The number of elements in the array.
+
+\pnum
+\complexity
+Constant.
 \end{itemdescr}
 
-\indexlibrary{\idxcode{end(initializer_list<E>)}}%
+\indexlibrarymember{empty}{initializer_list}%
 \begin{itemdecl}
-template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
+constexpr bool empty() const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{il.end()}.
+\tcode{size() == 0}.
 \end{itemdescr}
 
 \rSec1[cmp]{Comparisons}
diff --git a/source/utilities.tex b/source/utilities.tex
index 5e93b63c63..1228fe9220 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -7046,6 +7046,9 @@
 \indexheader{any}%
 
 \begin{codeblock}
+#include <initializer_list>     // see \ref{initializer.list.syn}
+#include <typeinfo>             // see \ref{typeinfo.syn}
+
 namespace std {
   // \ref{any.bad.any.cast}, class \tcode{bad_any_cast}
   class bad_any_cast;
@@ -11250,6 +11253,9 @@
 \indexlibraryglobal{unwrap_ref_decay}%
 \indexlibraryglobal{unwrap_ref_decay_t}%
 \begin{codeblock}
+#include <initializer_list>     // see \ref{initializer.list.syn}
+#include <typeinfo>             // see \ref{typeinfo.syn}
+
 namespace std {
   // \ref{func.invoke}, invoke
   template<class F, class... Args>
diff --git a/source/xrefdelta.tex b/source/xrefdelta.tex
index e1c6be970c..b0ed29aaaf 100644
--- a/source/xrefdelta.tex
+++ b/source/xrefdelta.tex
@@ -454,6 +454,9 @@
 % CWG 2843 removed [uaxid.def.rfmt]
 \removedxref{uaxid.def.rfmt}
 
+% P3016R6 Resolve inconsistencies in begin/end for valarray and braced intializers
+\removedxref{support.initlist.range}
+
 %%% Renamed sections.
 %%% Examples:
 %