diff --git a/source/algorithms.tex b/source/algorithms.tex
index d723b7e11a..8a90e3acfa 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -11167,13 +11167,20 @@
 
 \pnum
 Some algorithms specified in \ref{specialized.algorithms}
-make use of the exposition-only function template
-\tcode{\placeholdernc{voidify}}:
+make use of the following exposition-only function templates:
 \begin{codeblock}
 template<class T>
   constexpr void* @\placeholdernc{voidify}@(T& obj) noexcept {
     return addressof(obj);
   }
+
+template<class I>
+  decltype(auto) @\exposid{deref-move}@(I& it) {
+    if constexpr (is_lvalue_reference_v<decltype(*it)>)
+      return std::move(*it);
+    else
+      return *it;
+  }
 \end{codeblock}
 
 \rSec2[special.mem.concepts]{Special memory concepts}
@@ -11550,7 +11557,7 @@
 \begin{codeblock}
 for (; first != last; (void)++result, ++first)
   ::new (@\placeholdernc{voidify}@(*result))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
+    typename iterator_traits<NoThrowForwardIterator>::value_type(@\exposid{deref-move}@(first));
 return result;
 \end{codeblock}
 \end{itemdescr}
@@ -11610,7 +11617,7 @@
 \begin{codeblock}
 for (; n > 0; ++result, (void) ++first, --n)
   ::new (@\placeholdernc{voidify}@(*result))
-    typename iterator_traits<NoThrowForwardIterator>::value_type(std::move(*first));
+    typename iterator_traits<NoThrowForwardIterator>::value_type(@\exposid{deref-move}@(first));
 return {first, result};
 \end{codeblock}
 \end{itemdescr}
@@ -11741,14 +11748,22 @@
 \begin{itemdescr}
 \pnum
 \constraints
-The expression \tcode{::new (declval<void*>()) T(declval<Args>()...)}
+\tcode{is_unbounded_array_v<T>} is \tcode{false}.
+The expression \tcode{::new (declval<void*>()) T(\linebreak{}declval<Args>()...)}
 is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
+\pnum
+\mandates
+If \tcode{is_array_v<T>} is \tcode{true}, \tcode{sizeof...(Args)} is zero.
+
 \pnum
 \effects
 Equivalent to:
 \begin{codeblock}
-return ::new (@\placeholdernc{voidify}@(*location)) T(std::forward<Args>(args)...);
+if constexpr (is_array_v<T>)
+  return ::new (@\placeholdernc{voidify}@(*location)) T[1]();
+else
+  return ::new (@\placeholdernc{voidify}@(*location)) T(std::forward<Args>(args)...);
 \end{codeblock}
 \end{itemdescr}
 
@@ -11919,7 +11934,8 @@
 \begin{itemdecl}
 template<class R, class G, class D>
   requires @\libconcept{output_range}@<R, invoke_result_t<D&, G&>> && @\libconcept{invocable}@<D&, G&> &&
-           @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>>
+           @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>> &&
+           is_arithmetic_v<invoke_result_t<D&, G&>>
 constexpr borrowed_iterator_t<R> ranges::generate_random(R&& r, G&& g, D&& d);
 \end{itemdecl}
 
@@ -11968,7 +11984,8 @@
 
 \begin{itemdecl}
 template<class G, class D, @\libconcept{output_iterator}@<invoke_result_t<D&, G&>> O, @\libconcept{sentinel_for}@<O> S>
-  requires @\libconcept{invocable}@<D&, G&> && @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>>
+  requires @\libconcept{invocable}@<D&, G&> && @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>> &&
+           is_arithmetic_v<invoke_result_t<D&, G&>>
 constexpr O ranges::generate_random(O first, S last, G&& g, D&& d);
 \end{itemdecl}
 
diff --git a/source/containers.tex b/source/containers.tex
index f8a7f0c3e4..7652a308fc 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -1463,7 +1463,7 @@
 \pnum
 \expects
 \tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{X} from \tcode{args}.
-For \tcode{vector} and \tcode{deque},
+For \tcode{vector}, \tcode{inplace_vector}, and \tcode{deque},
 \tcode{T} is also \oldconcept{MoveInsertable} into \tcode{X} and
 \oldconcept{MoveAssignable}.
 
@@ -7200,10 +7200,13 @@
 \rSec3[forward.list.modifiers]{Modifiers}
 
 \pnum
-None of the overloads of \tcode{insert_after} shall affect the validity of iterators and
-references, and \tcode{erase_after} shall invalidate only iterators and references to
-the erased elements. If an exception is thrown during \tcode{insert_after} there shall
-be no effect. Inserting \tcode{n} elements into a \tcode{forward_list} is linear in
+The member functions in this subclause
+do not affect the validity of iterators and references
+when inserting elements, and when erasing elements
+invalidate iterators and references to the erased elements only.
+If an exception is thrown by any of these member functions
+there is no effect on the container.
+Inserting \tcode{n} elements into a \tcode{forward_list} is linear in
 \tcode{n}, and the number of calls to the copy or move constructor of \tcode{T} is
 exactly equal to \tcode{n}. Erasing \tcode{n} elements from a \tcode{forward_list} is
 linear in \tcode{n} and the number of calls to the destructor of type \tcode{T} is
@@ -7780,7 +7783,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to: \tcode{return erase_if(c, [\&](auto\& elem) \{ return elem == value; \});}
+Equivalent to: \tcode{return erase_if(c, [\&](const auto\& elem) -> bool \{ return elem == value; \});}
 \end{itemdescr}
 
 \indexlibrarymember{erase_if}{forward_list}%
@@ -8564,7 +8567,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to: \tcode{return erase_if(c, [\&](auto\& elem) \{ return elem == value; \});}
+Equivalent to: \tcode{return erase_if(c, [\&](const auto\& elem) -> bool \{ return elem == value; \});}
 \end{itemdescr}
 
 \indexlibrarymember{erase_if}{list}%
@@ -9255,8 +9258,6 @@
 
     // bit reference
     class @\libmember{reference}{vector<bool>}@ {
-      constexpr reference() noexcept;
-
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 9aaee4e353..528c4fb005 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -6816,7 +6816,7 @@
 \effects
 Equivalent to:
 \begin{codeblock}
-print(os, "{}\n", format(fmt, std::forward<Args>(args)...));
+print(os, "{}\n", format(os.getloc(), fmt, std::forward<Args>(args)...));
 \end{codeblock}
 \end{itemdescr}
 
@@ -6854,25 +6854,31 @@
 without regard to the value of \tcode{os.exceptions()} and
 without turning on \tcode{ios_base::badbit} in the error state of \tcode{os}.
 \end{itemize}
+
+\par % This paragraph is part of the \effects clause.
 After constructing a \tcode{sentry} object,
 the function initializes a variable with automatic storage duration via
 \begin{codeblock}
 string out = vformat(os.getloc(), fmt, args);
 \end{codeblock}
+\begin{itemize}
+\item
 If the function is \tcode{vprint_unicode} and
-\tcode{os} is a stream that refers to a terminal capable of displaying Unicode
+\tcode{os} is a stream that refers to a terminal that
+is capable of displaying Unicode only via a native Unicode API,
 which is determined in an implementation-defined manner,
+flushes \tcode{os} and then
 writes \tcode{out} to the terminal using the native Unicode API;
 if \tcode{out} contains invalid code units,
 \indextext{undefined}%
-the behavior is undefined and
-implementations are encouraged to diagnose it.
-If the native Unicode API is used,
-the function flushes \tcode{os} before writing \tcode{out}.
-Otherwise (if \tcode{os} is not such a stream or
-the function is \tcode{vprint_nonunicode}),
+the behavior is undefined.
+\item
+Otherwise
 inserts the character sequence
 \range{out.begin()}{out.end()} into \tcode{os}.
+\end{itemize}
+
+\par % This paragraph is part of the \effects clause.
 If writing to the terminal or inserting into \tcode{os} fails,
 calls \tcode{os.setstate(ios_base::badbit)}
 (which may throw \tcode{ios_base::failure}).
@@ -7837,28 +7843,27 @@
 Let \tcode{out} denote the character representation of
 formatting arguments provided by \tcode{args}
 formatted according to specifications given in \tcode{fmt}.
-If \tcode{stream} refers to a terminal capable of displaying Unicode,
+\begin{itemize}
+\item
+If \tcode{stream} refers to a terminal that
+is capable of displaying Unicode only via a native Unicode API,
+flushes \tcode{stream} and then
 writes \tcode{out} to the terminal using the native Unicode API;
 if \tcode{out} contains invalid code units,
 \indextext{undefined}%
-the behavior is undefined and
-implementations are encouraged to diagnose it.
+the behavior is undefined.
+\item
 Otherwise writes \tcode{out} to \tcode{stream} unchanged.
-If the native Unicode API is used,
-the function flushes \tcode{stream} before writing \tcode{out}.
+\end{itemize}
 Unconditionally unlocks \tcode{stream} on function exit.
 
 \xrefc{7.21.2}.
 
 \begin{note}
-On POSIX and Windows, \tcode{stream} referring to a terminal means that,
-respectively,
-\tcode{isatty(fileno(\linebreak{}stream))} and
+On Windows the native Unicode API is \tcode{WriteConsoleW} and
+\tcode{stream} referring to a terminal means that
 \tcode{GetConsoleMode(_get_osfhandle(_fileno(stream)), ...)}
-return nonzero.
-\end{note}
-\begin{note}
-On Windows, the native Unicode API is \tcode{WriteConsoleW}.
+returns nonzero.
 \end{note}
 
 \pnum
diff --git a/source/iterators.tex b/source/iterators.tex
index 31bda1bfe8..703c56becf 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -1969,6 +1969,7 @@
 \item \tcode{to_address(a) == addressof(*a)},
 \item \tcode{to_address(b) == to_address(a) + D(b - a)},
 \item \tcode{to_address(c) == to_address(a) + D(c - a)},
+\item \tcode{to_address(I\{\})} is well-defined,
 \item \tcode{ranges::iter_move(a)} has
 the same type, value category, and effects as \tcode{std::move(*a)}, and
 \item if \tcode{ranges::iter_swap(a, b)} is well-formed,
diff --git a/source/memory.tex b/source/memory.tex
index 1260365953..5c3fbbb90a 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -2084,6 +2084,14 @@
 }
 \end{codeblock}
 
+\pnum
+A program that instantiates the definition of \tcode{unique_ptr<T, D>}
+is ill-formed if \tcode{T*} is an invalid type.
+\begin{note}
+This prevents the intantiation of specializations such as
+\tcode{unique_ptr<T\&, D>} and \tcode{unique_ptr<int() const, D>}.
+\end{note}
+
 \pnum
 The default type for the template parameter \tcode{D} is
 \tcode{default_delete}. A client-supplied template argument
@@ -2434,9 +2442,13 @@
 \end{itemdecl}
 
 \begin{itemdescr}
+\pnum
+\mandates
+\tcode{reference_converts_from_temporary_v<add_lvalue_reference_t<T>, decltype(\linebreak{}*declval<pointer>())>} is \tcode{false}.
+
 \pnum
 \expects
-\tcode{get() != nullptr}.
+\tcode{get() != nullptr} is \tcode{true}.
 
 \pnum
 \returns
@@ -3970,15 +3982,15 @@
   \tcode{allocate_shared} shall initialize this (sub)object
   via the expression
   \begin{itemize}
-  \item \tcode{allocator_traits<A2>::construct(a2, pv, v)} or
-  \item \tcode{allocator_traits<A2>::construct(a2, pv, l...)}
+  \item \tcode{allocator_traits<A2>::construct(a2, pu, v)} or
+  \item \tcode{allocator_traits<A2>::construct(a2, pu, l...)}
   \end{itemize}
   respectively,
-  where \tcode{pv} points to storage
-  suitable to hold an object of type \tcode{U} and
-  \tcode{a2} of type \tcode{A2} is a rebound copy of
-  the allocator \tcode{a} passed to \tcode{allocate_shared}
-  such that its \tcode{value_type} is \tcode{remove_cv_t<U>}.
+  where \tcode{pu} is a pointer of type \tcode{remove_cv_t<U>*}
+  pointing to storage
+  suitable to hold an object of type \tcode{remove_cv_t<U>} and
+  \tcode{a2} of type \tcode{A2} is a potentially rebound copy of
+  the allocator \tcode{a} passed to \tcode{allocate_shared}.
 \item
   When a (sub)object of non-array type \tcode{U} is specified to have
   a default initial value,
@@ -3989,13 +4001,13 @@
 \item
   When a (sub)object of non-array type \tcode{U} is specified to have
   a default initial value,
-  \tcode{allocate_shared} shall initialize this (sub)object
-  via the expression \tcode{allocator_traits<A2>::construct(a2, pv)},
-  where \tcode{pv} points to storage
-  suitable to hold an object of type \tcode{U} and
-  \tcode{a2} of type \tcode{A2} is a rebound copy of
-  the allocator \tcode{a} passed to \tcode{allocate_shared}
-  such that its \tcode{value_type} is \tcode{remove_cv_t<U>}.
+  \tcode{allocate_shared} initializes this (sub)object
+  via the expression \tcode{allocator_traits<A2>::construct(a2, pu)},
+  where \tcode{pu} is a pointer of type \tcode{remove_cv_t<U>*}
+  pointing to storage
+  suitable to hold an object of type \tcode{remove_cv_t<U>} and
+  \tcode{a2} of type \tcode{A2} is a potentially rebound copy of
+  the allocator \tcode{a} passed to \tcode{allocate_shared}.
 \item
   When a (sub)object of non-array type \tcode{U} is initialized by
   \tcode{make_shared_for_overwrite} or\linebreak % avoid Overfull
@@ -4012,18 +4024,20 @@
   of their original construction.
 \item
   When a (sub)object of non-array type \tcode{U}
-  that was initialized by \tcode{make_shared} is to be destroyed,
-  it is destroyed via the expression \tcode{pv->\~{}U()} where
-  \tcode{pv} points to that object of type \tcode{U}.
+  that was initialized by \tcode{make_shared},
+  \tcode{make_shared_for_overwrite}, or \tcode{allocate_shared_for_overwrite}
+  is to be destroyed,
+  it is destroyed via the expression \tcode{pu->\~{}U()} where
+  \tcode{pu} points to that object of type \tcode{U}.
 \item
   When a (sub)object of non-array type \tcode{U}
   that was initialized by \tcode{allocate_shared} is to be destroyed,
   it is destroyed via the expression
-  \tcode{allocator_traits<A2>::destroy(a2, pv)} where
-  \tcode{pv} points to that object of type \tcode{remove_cv_t<U>} and
-  \tcode{a2} of type \tcode{A2} is a rebound copy of
-  the allocator \tcode{a} passed to \tcode{allocate_shared}
-  such that its \tcode{value_type} is \tcode{remove_cv_t<U>}.
+  \tcode{allocator_traits<A2>::destroy(a2, pu)} where
+  \tcode{pu} is a pointer of type \tcode{remove_cv_t<U>*}
+  pointing to that object of type \tcode{remove_cv_t<U>} and
+  \tcode{a2} of type \tcode{A2} is a potentially rebound copy of
+  the allocator \tcode{a} passed to \tcode{allocate_shared}.
 \end{itemize}
 \begin{note}
 These functions will typically allocate more memory than \tcode{sizeof(T)} to
diff --git a/source/meta.tex b/source/meta.tex
index 6114f69ab0..d6bf2847cb 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -1217,8 +1217,8 @@
   For an array type \tcode{T}, the same result as
   \tcode{has_unique_object_representations_v<remove_all_extents_t<T>>},
   otherwise \seebelow. &
-  \tcode{T} shall be a complete type, \cv{}~\keyword{void}, or
-  an array of unknown bound. \\ \rowsep
+  \tcode{remove_all_extents_t<T>} shall be a complete type or
+  \cv{}~\keyword{void}.  \\ \rowsep
 
 \indexlibraryglobal{reference_constructs_from_temporary}%
 \tcode{template<class T, class U>}\br
diff --git a/source/numerics.tex b/source/numerics.tex
index b5c31916ab..f07eeb83de 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -1451,11 +1451,13 @@
 
     template<class R, class G, class D>
       requires @\libconcept{output_range}@<R, invoke_result_t<D&, G&>> && @\libconcept{invocable}@<D&, G&> &&
-               @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>>
+               @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>> &&
+               is_arithmetic_v<invoke_result_t<D&, G&>>
     constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g, D&& d);
 
     template<class G, class D, @\libconcept{output_iterator}@<invoke_result_t<D&, G&>> O, @\libconcept{sentinel_for}@<O> S>
-      requires @\libconcept{invocable}@<D&, G&> && @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>>
+      requires @\libconcept{invocable}@<D&, G&> && @\libconcept{uniform_random_bit_generator}@<remove_cvref_t<G>> &&
+               is_arithmetic_v<invoke_result_t<D&, G&>>
     constexpr O generate_random(O first, S last, G&& g, D&& d);
   }
 
@@ -3033,8 +3035,8 @@
  first construct \tcode{e}, a \tcode{linear_congruential_engine} object,
  as if by the following definition:
 \begin{codeblock}
-linear_congruential_engine<uint_least32_t,
-                          40014u,0u,2147483563u> e(value == 0u ? default_seed : value);
+linear_congruential_engine<uint_least32_t, 40014u, 0u, 2147483563u> e(
+  value == 0u ? default_seed : static_cast<uint_least32_t>(value % 2147483563u));
 \end{codeblock}
  Then, to set each $X_k$,
  obtain new values $z_0, \dotsc, z_{n-1}$
@@ -3077,8 +3079,8 @@
 
 \pnum
 A \tcode{philox_engine} random number engine produces
-unsigned integer random numbers in the closed interval \crange{0}{$m$},
-where $m = 2^w - 1$ and
+unsigned integer random numbers in the interval \range{0}{$m$},
+where $m = 2^w$ and
 the template parameter $w$ defines the range of the produced numbers.
 The state of a \tcode{philox_engine} object consists of
 a sequence $X$ of $n$ unsigned integer values of width $w$,
@@ -3131,15 +3133,13 @@
 $f_n(j)$ is defined in \tref{rand.eng.philox.f}.
 
 \begin{floattable}{Values for the word permutation $\bm{f}_{\bm{n}}\bm{(j)}$}{rand.eng.philox.f}
-{l|l|l|l|l|l|l|l|l|l|l|l|l|l|l|l|l|l}
+{l|l|l|l|l|l}
 \topline
-  \multicolumn{2}{|c|}{$\bm{f}_{\bm{n}}\bm{(j)}$} & \multicolumn{16}{c|}{$\bm{j}$} \\ \cline{3-18}
+  \multicolumn{2}{|c|}{$\bm{f}_{\bm{n}}\bm{(j)}$} & \multicolumn{4}{c|}{$\bm{j}$} \\ \cline{3-6}
   \multicolumn{2}{|c|}{}
-    & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15 \\ \hline
-  $\bm{n} $ & 2 & 0 & 1 & \multicolumn{14}{c|}{} \\ \cline{2-18}
-  & 4 & 0 & 3 & 2 & 1 & \multicolumn{12}{c|}{} \\ \cline{2-18}
-  & 8 & 2 & 1 & 4 & 7 & 6 & 5 & 0 & 3 & \multicolumn{8}{c|}{} \\ \cline{2-18}
-  & 16 & 0 & 9 & 2 & 13 & 6 & 11 & 4 & 15 & 10 & 7 & 12 & 3 & 14 & 5 & 8 & 1 \\ \cline{2-18}
+    & 0 & 1 & 2 & 3 \\ \hline
+  $\bm{n} $ & 2 & 0 & 1 & \multicolumn{2}{c|}{} \\ \cline{2-6}
+  & 4 & 2 & 1 & 0 & 3 \\ \cline{2-6}
 \end{floattable}
 \begin{note}
 For $n = 2$ the sequence is not permuted.
@@ -3148,8 +3148,8 @@
 \item
 The following computations are applied to the elements of the $V$ sequence:
 \begin{codeblock}
-@$X_{2k + 0} = \mullo(V_{2k + 1}, M_{k}, w)$@
-@$X_{2k + 1} = \mulhi(V_{2k + 1}, M_{k}, w) \xor \mathit{key}^q_k \xor V_{2k}$@
+@$X_{2k + 0} = \mulhi(V_{2k}, M_{k}, w) \xor \mathit{key}^q_k \xor V_{2k + 1}$@
+@$X_{2k + 1} = \mullo(V_{2k}, M_{k}, w)$@
 \end{codeblock}
 where:
   \begin{itemize}
@@ -3240,7 +3240,7 @@
 \mandates
 \begin{itemize}
 \item \tcode{sizeof...(consts) == n} is \tcode{true}, and
-\item \tcode{n == 2 || n == 4 || n == 8 || n == 16} is \tcode{true}, and
+\item \tcode{n == 2 || n == 4} is \tcode{true}, and
 \item \tcode{0 < r} is \tcode{true}, and
 \item \tcode{0 < w \&\& w <= numeric_limits<UIntType>::digits} is \tcode{true}.
 \end{itemize}
@@ -3908,7 +3908,7 @@
 \begin{itemdecl}
 using philox4x32 =
       philox_engine<uint_fast32_t, 32, 4, 10,
-       0xD2511F53, 0x9E3779B9, 0xCD9E8D57, 0xBB67AE85>;
+       0xCD9E8D57, 0x9E3779B9, 0xD2511F53, 0xBB67AE85>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3923,7 +3923,7 @@
 \begin{itemdecl}
 using philox4x64 =
       philox_engine<uint_fast64_t, 64, 4, 10,
-       0xD2E7470EE14C6C93, 0x9E3779B97F4A7C15, 0xCA5A826395121157, 0xBB67AE8584CAA73B>;
+       0xCA5A826395121157, 0x9E3779B97F4A7C15, 0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>;
 \end{itemdecl}
 
 \begin{itemdescr}
diff --git a/source/ranges.tex b/source/ranges.tex
index 4c9f0a7321..c84aafe476 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -396,7 +396,7 @@
   // \ref{range.as.const}, as const view
   template<@\libconcept{input_range}@ R>
     constexpr auto& @\exposid{possibly-const-range}@(R& r) noexcept { // \expos
-      if constexpr (@\libconcept{constant_range}@<const R> && !@\libconcept{constant_range}@<R>) {
+      if constexpr (@\libconcept{input_range}@<const R>) {
         return const_cast<const R&>(r);
       } else {
         return r;
@@ -1634,7 +1634,7 @@
 
 template<class I>
   concept @\defexposconceptnc{has-arrow}@ =                                       // \expos
-    @\libconcept{input_iterator}@<I> && (is_pointer_v<I> || requires(I i) { i.operator->(); });
+    @\libconcept{input_iterator}@<I> && (is_pointer_v<I> || requires(const I i) { i.operator->(); });
 
 template<class T, class U>
   concept @\defexposconceptnc{different-from}@ =                                  // \expos
@@ -16995,6 +16995,9 @@
     template<class R2, class V2, class Alloc2, class Unused>
       requires @\libconcept{same_as}@<typename generator<R2, V2, Alloc2>::yielded, yielded>
         auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
+    template<class R2, class V2, class Alloc2, class Unused>
+      requires @\libconcept{same_as}@<typename generator<R2, V2, Alloc2>::yielded, yielded>
+        auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&, Unused> g) noexcept;
 
     template<ranges::@\libconcept{input_range}@ R, class Alloc>
       requires @\libconcept{convertible_to}@<ranges::range_reference_t<R>, yielded>
@@ -17009,13 +17012,11 @@
       requires @\libconcept{same_as}@<Allocator, void> || @\libconcept{default_initializable}@<Allocator>;
 
     template<class Alloc, class... Args>
-      requires @\libconcept{same_as}@<Allocator, void> || @\libconcept{convertible_to}@<const Alloc&, Allocator>
-        void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
+      void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
 
     template<class This, class Alloc, class... Args>
-      requires @\libconcept{same_as}@<Allocator, void> || @\libconcept{convertible_to}@<const Alloc&, Allocator>
-        void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
-                           const Args&...);
+      void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
+                         const Args&...);
 
     void operator delete(void* pointer, size_t size) noexcept;
 
@@ -17122,6 +17123,9 @@
 template<class R2, class V2, class Alloc2, class Unused>
   requires @\libconcept{same_as}@<typename generator<R2, V2, Alloc2>::yielded, yielded>
   auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
+template<class R2, class V2, class Alloc2, class Unused>
+  requires @\libconcept{same_as}@<typename generator<R2, V2, Alloc2>::yielded, yielded>
+  auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&, Unused> g) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17154,7 +17158,7 @@
 
 \pnum
 \remarks
-A \grammarterm{yield-expression} that calls this function
+A \grammarterm{yield-expression} that calls one of these functions
 has type \tcode{void}\iref{expr.yield}.
 \end{itemdescr}
 
@@ -17171,7 +17175,7 @@
 Equivalent to:
 \begin{codeblock}
 auto nested = [](allocator_arg_t, Alloc, ranges::iterator_t<R> i, ranges::sentinel_t<R> s)
-  -> generator<yielded, ranges::range_value_t<R>, Alloc> {
+  -> generator<yielded, void, Alloc> {
     for (; i != s; ++i) {
       co_yield static_cast<yielded>(*i);
     }
@@ -17214,11 +17218,9 @@
   requires @\libconcept{same_as}@<Allocator, void> || @\libconcept{default_initializable}@<Allocator>;
 
 template<class Alloc, class... Args>
-  requires @\libconcept{same_as}@<Allocator, void> || @\libconcept{convertible_to}@<const Alloc&, Allocator>
   void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
 
 template<class This, class Alloc, class... Args>
-  requires @\libconcept{same_as}@<Allocator, void> || @\libconcept{convertible_to}@<const Alloc&, Allocator>
   void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc,
                      const Args&...);
 \end{itemdecl}
@@ -17241,6 +17243,9 @@
 \pnum
 \mandates
 \tcode{allocator_traits<B>::pointer} is a pointer type.
+For the overloads with a template parameter \tcode{Alloc},
+\tcode{\libconcept{same_as}<Allocator, void> || \libconcept{convertible_to}<const Alloc\&, Allocator>}
+is modeled.
 
 \pnum
 \effects
diff --git a/source/strings.tex b/source/strings.tex
index f9591bd9cb..48e2bee8a3 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -5515,9 +5515,11 @@
 \indextext{signal-safe!\idxcode{memcpy}}%
 \indextext{signal-safe!\idxcode{memmove}}%
 The functions \tcode{memcpy} and \tcode{memmove} are signal-safe\iref{support.signal}.
-Both functions implicitly create objects\iref{intro.object}
+Each of these functions implicitly creates objects\iref{intro.object}
 in the destination region of storage
 immediately prior to copying the sequence of characters to the destination.
+Each of these functions returns a pointer to a suitable created object, if any,
+otherwise the value of the first parameter.
 
 \pnum
 \begin{note}
diff --git a/source/support.tex b/source/support.tex
index b4241cff88..5c9c6fa3b3 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -597,14 +597,14 @@
 #define @\defnlibxname{cpp_lib_chrono}@                            202306L // also in \libheader{chrono}
 #define @\defnlibxname{cpp_lib_chrono_udls}@                       201304L // also in \libheader{chrono}
 #define @\defnlibxname{cpp_lib_clamp}@                             201603L // also in \libheader{algorithm}
-#define @\defnlibxname{cpp_lib_common_reference}@                  202302L // also in \libheader{type_traits}
-#define @\defnlibxname{cpp_lib_common_reference_wrapper}@          202302L // also in \libheader{functional}
+#define @\defnlibxname{cpp_lib_common_reference}@                  202302L // freestanding, also in \libheader{type_traits}
+#define @\defnlibxname{cpp_lib_common_reference_wrapper}@          202302L // freestanding, also in \libheader{functional}
 #define @\defnlibxname{cpp_lib_complex_udls}@                      201309L // also in \libheader{complex}
 #define @\defnlibxname{cpp_lib_concepts}@                          202207L
   // freestanding, also in \libheader{concepts}, \libheader{compare}
 #define @\defnlibxname{cpp_lib_constexpr_algorithms}@              202306L // also in \libheader{algorithm}, \libheader{utility}
 #define @\defnlibxname{cpp_lib_constexpr_bitset}@                  202207L // also in \libheader{bitset}
-#define @\defnlibxname{cpp_lib_constexpr_charconv}@                202207L // also in \libheader{charconv}
+#define @\defnlibxname{cpp_lib_constexpr_charconv}@                202207L // freestanding, also in \libheader{charconv}
 #define @\defnlibxname{cpp_lib_constexpr_cmath}@                   202306L // also in \libheader{cmath}, \libheader{cstdlib}
 #define @\defnlibxname{cpp_lib_constexpr_complex}@                 202306L // also in \libheader{complex}
 #define @\defnlibxname{cpp_lib_constexpr_dynamic_alloc}@           201907L // also in \libheader{memory}
@@ -626,7 +626,7 @@
   // also in \libheader{vector}, \libheader{list}, \libheader{forward_list}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set},
   // \libheader{deque}, \libheader{queue}, \libheader{stack}, \libheader{string}
 #define @\defnlibxname{cpp_lib_copyable_function}@                 202306L // also in \libheader{functional}
-#define @\defnlibxname{cpp_lib_coroutine}@                         201902L // also in \libheader{coroutine}
+#define @\defnlibxname{cpp_lib_coroutine}@                         201902L // freestanding, also in \libheader{coroutine}
 #define @\defnlibxname{cpp_lib_debugging}@                         202403L // freestanding, also in \libheader{debugging}
 #define @\defnlibxname{cpp_lib_destroying_delete}@                 201806L // freestanding, also in \libheader{new}
 #define @\defnlibxname{cpp_lib_enable_shared_from_this}@           201603L // also in \libheader{memory}
@@ -695,7 +695,7 @@
 #define @\defnlibxname{cpp_lib_is_aggregate}@                      201703L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_constant_evaluated}@             201811L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_final}@                          201402L // freestanding, also in \libheader{type_traits}
-#define @\defnlibxname{cpp_lib_is_implicit_lifetime}@              202302L // also in \libheader{type_traits}
+#define @\defnlibxname{cpp_lib_is_implicit_lifetime}@              202302L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_invocable}@                      201703L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_layout_compatible}@              201907L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_nothrow_convertible}@            201806L // freestanding, also in \libheader{type_traits}
@@ -703,8 +703,8 @@
 #define @\defnlibxname{cpp_lib_is_pointer_interconvertible}@       201907L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_scoped_enum}@                    202011L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_is_swappable}@                      201603L // freestanding, also in \libheader{type_traits}
-#define @\defnlibxname{cpp_lib_is_virtual_base_of}@                202406L // also in \libheader{type_traits}
-#define @\defnlibxname{cpp_lib_is_within_lifetime}@                202306L // also in \libheader{type_traits}
+#define @\defnlibxname{cpp_lib_is_virtual_base_of}@                202406L // freestanding, also in \libheader{type_traits}
+#define @\defnlibxname{cpp_lib_is_within_lifetime}@                202306L // freestanding, also in \libheader{type_traits}
 #define @\defnlibxname{cpp_lib_jthread}@                           201911L // also in \libheader{stop_token}, \libheader{thread}
 #define @\defnlibxname{cpp_lib_latch}@                             201907L // also in \libheader{latch}
 #define @\defnlibxname{cpp_lib_launder}@                           201606L // freestanding, also in \libheader{new}
@@ -717,7 +717,7 @@
 #define @\defnlibxname{cpp_lib_map_try_emplace}@                   201411L // also in \libheader{map}
 #define @\defnlibxname{cpp_lib_math_constants}@                    201907L // also in \libheader{numbers}
 #define @\defnlibxname{cpp_lib_math_special_functions}@            201603L // also in \libheader{cmath}
-#define @\defnlibxname{cpp_lib_mdspan}@                            202406L // also in \libheader{mdspan}
+#define @\defnlibxname{cpp_lib_mdspan}@                            202406L // freestanding, also in \libheader{mdspan}
 #define @\defnlibxname{cpp_lib_memory_resource}@                   201603L // also in \libheader{memory_resource}
 #define @\defnlibxname{cpp_lib_modules}@                           202207L // freestanding
 #define @\defnlibxname{cpp_lib_move_iterator_concept}@             202207L // freestanding, also in \libheader{iterator}
@@ -759,7 +759,7 @@
 #define @\defnlibxname{cpp_lib_ranges_to_container}@               202202L // freestanding, also in \libheader{ranges}
 #define @\defnlibxname{cpp_lib_ranges_zip}@                        202110L
   // freestanding, also in \libheader{ranges}, \libheader{tuple}, \libheader{utility}
-#define @\defnlibxname{cpp_lib_ratio}@                             202306L // also in \libheader{ratio}
+#define @\defnlibxname{cpp_lib_ratio}@                             202306L // freestanding, also in \libheader{ratio}
 #define @\defnlibxname{cpp_lib_raw_memory_algorithms}@             201606L // also in \libheader{memory}
 #define @\defnlibxname{cpp_lib_rcu}@                               202306L // also in \libheader{rcu}
 #define @\defnlibxname{cpp_lib_reference_from_temporary}@          202202L // freestanding, also in \libheader{type_traits}
@@ -782,7 +782,7 @@
 #define @\defnlibxname{cpp_lib_smart_ptr_owner_equality}@          202306L // also in \libheader{memory}
 #define @\defnlibxname{cpp_lib_source_location}@                   201907L // freestanding, also in \libheader{source_location}
 #define @\defnlibxname{cpp_lib_span}@                              202311L // freestanding, also in \libheader{span}
-#define @\defnlibxname{cpp_lib_span_initializer_list}@             202311L // also in \libheader{span}
+#define @\defnlibxname{cpp_lib_span_initializer_list}@             202311L // freestanding, also in \libheader{span}
 #define @\defnlibxname{cpp_lib_spanstream}@                        202106L // also in \libheader{spanstream}
 #define @\defnlibxname{cpp_lib_ssize}@                             201902L // freestanding, also in \libheader{iterator}
 #define @\defnlibxname{cpp_lib_sstream_from_string_view}@          202306L // also in \libheader{sstream}
@@ -794,12 +794,12 @@
 #define @\defnlibxname{cpp_lib_string_resize_and_overwrite}@       202110L // also in \libheader{string}
 #define @\defnlibxname{cpp_lib_string_udls}@                       201304L // also in \libheader{string}
 #define @\defnlibxname{cpp_lib_string_view}@                       202403L // also in \libheader{string}, \libheader{string_view}
-#define @\defnlibxname{cpp_lib_submdspan}@                         202403L // also in \libheader{mdspan}
+#define @\defnlibxname{cpp_lib_submdspan}@                         202403L // freestanding, also in \libheader{mdspan}
 #define @\defnlibxname{cpp_lib_syncbuf}@                           201803L // also in \libheader{syncstream}
 #define @\defnlibxname{cpp_lib_text_encoding}@                     202306L // also in \libheader{text_encoding}
 #define @\defnlibxname{cpp_lib_three_way_comparison}@              201907L // freestanding, also in \libheader{compare}
 #define @\defnlibxname{cpp_lib_to_address}@                        201711L // freestanding, also in \libheader{memory}
-#define @\defnlibxname{cpp_lib_to_array}@                          201907L // also in \libheader{array}
+#define @\defnlibxname{cpp_lib_to_array}@                          201907L // freestanding, also in \libheader{array}
 #define @\defnlibxname{cpp_lib_to_chars}@                          202306L // also in \libheader{charconv}
 #define @\defnlibxname{cpp_lib_to_string}@                         202306L // also in \libheader{string}
 #define @\defnlibxname{cpp_lib_to_underlying}@                     202102L // freestanding, also in \libheader{utility}
@@ -5302,7 +5302,8 @@
   Otherwise, if the expressions
   \tcode{E == F}, \tcode{E < F}, and \tcode{F < E}
   are all well-formed and
-  each of \tcode{decltype(E == F)} and \tcode{decltype(E < F)} models
+  each of \tcode{decltype(E == F)}, \tcode{decltype(E < F)}, and
+  \tcode{decltype(F < E)} models
   \exposconcept{boolean-testable},
 \begin{codeblock}
 E == F ? partial_ordering::equivalent :
diff --git a/source/text.tex b/source/text.tex
index 569c36620e..067ff01944 100644
--- a/source/text.tex
+++ b/source/text.tex
@@ -2965,7 +2965,8 @@
 {lc}
 \topline
 \lhdr{State}            & \rhdr{\tcode{stdio} equivalent}  \\ \capsep
-\tcode{floatfield == ios_base::fixed}                       &   \tcode{\%f} \\ \rowsep
+\tcode{floatfield == ios_base::fixed \&\& !uppercase}       &   \tcode{\%f} \\ \rowsep
+\tcode{floatfield == ios_base::fixed}                       &   \tcode{\%F} \\ \rowsep
 \tcode{floatfield == ios_base::scientific \&\& !uppercase}  &   \tcode{\%e} \\ \rowsep
 \tcode{floatfield == ios_base::scientific}                  &   \tcode{\%E} \\ \rowsep
 \tcode{floatfield == (ios_base::fixed | ios_base::scientific) \&\& !uppercase} & \tcode{\%a} \\ \rowsep
@@ -7627,6 +7628,7 @@
 \begin{itemdescr}
 \pnum
 \mandates
+$\tcode{sizeof...(Ts)} \ge 1$.
 The types in \tcode{Ts...} are unique.
 Each type in \tcode{Ts...} is one of
 \keyword{bool},
diff --git a/source/threads.tex b/source/threads.tex
index ba8ddf5ea8..7dfd5eafce 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -4087,7 +4087,7 @@
 
 \begin{itemdescr}
 \pnum
-\mandates
+\constraints
 \tcode{is_default_constructible_v<T>} is \tcode{true}.
 
 \pnum
@@ -11861,16 +11861,13 @@
 
 \pnum
 \mandates
-\tcode{is_invocable_r_v<R, F\&, ArgTypes...>} is \tcode{true}.
-
-\pnum
-\expects
-Invoking a copy of \tcode{f} behaves the same as invoking \tcode{f}.
+\tcode{is_invocable_r_v<R, decay_t<F>\&, ArgTypes...>} is \tcode{true}.
 
 \pnum
 \effects
-Constructs a new \tcode{packaged_task} object with a shared state and
-initializes the object's stored task with \tcode{std::forward<F>(f)}.
+Constructs a new \tcode{packaged_task} object with
+a stored task of type \tcode{decay_t<F>} and a shared state.
+Initializes the object's stored task with \tcode{std::forward<F>(f)}.
 
 \pnum
 \throws
diff --git a/source/time.tex b/source/time.tex
index dfa1601013..f74e3a87fd 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -10994,6 +10994,9 @@
 
 \pnum
 \remarks
+If the \fmtgrammarterm{chrono-specs} is omitted,
+the result is equivalent to using \tcode{\%F \%T \%Z} as
+the \fmtgrammarterm{chrono-specs}.
 If \tcode{\%Z} is used,
 it is replaced with \tcode{*f.abbrev}
 if \tcode{f.abbrev} is not a null pointer value.
@@ -11012,7 +11015,7 @@
 \begin{codeblock}
 template<class Duration, class TimeZonePtr, class charT>
 struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>
-    : formatter<chrono::@\placeholder{local-time-format-t}@<Duration>, charT> {
+    : formatter<chrono::@\placeholder{local-time-format-t}@<common_type_t<Duration, seconds>>, charT> {
   template<class FormatContext>
     typename FormatContext::iterator
       format(const chrono::zoned_time<Duration, TimeZonePtr>& tp, FormatContext& ctx) const;
@@ -11032,7 +11035,7 @@
 Equivalent to:
 \begin{codeblock}
 sys_info info = tp.get_info();
-return formatter<chrono::@\placeholder{local-time-format-t}@<Duration>, charT>::
+return formatter<chrono::@\placeholder{local-time-format-t}@<common_type_t<Duration, seconds>>, charT>::
          format({tp.get_local_time(), &info.abbrev, &info.offset}, ctx);
 \end{codeblock}
 \end{itemdescr}
diff --git a/source/utilities.tex b/source/utilities.tex
index 889bba8d99..212449243a 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -3269,7 +3269,7 @@
       constexpr explicit optional(in_place_t, Args&&...);
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
-    template<class U = T>
+    template<class U = remove_cv_t<T>>
       constexpr explicit(@\seebelow@) optional(U&&);
     template<class U>
       constexpr explicit(@\seebelow@) optional(const optional<U>&);
@@ -3283,7 +3283,7 @@
     constexpr optional& operator=(nullopt_t) noexcept;
     constexpr optional& operator=(const optional&);
     constexpr optional& operator=(optional&&) noexcept(@\seebelow@);
-    template<class U = T> constexpr optional& operator=(U&&);
+    template<class U = remove_cv_t<T>> constexpr optional& operator=(U&&);
     template<class U> constexpr optional& operator=(const optional<U>&);
     template<class U> constexpr optional& operator=(optional<U>&&);
     template<class... Args> constexpr T& emplace(Args&&...);
@@ -3311,8 +3311,8 @@
     constexpr T& value() &;                                             // freestanding-deleted
     constexpr T&& value() &&;                                           // freestanding-deleted
     constexpr const T&& value() const &&;                               // freestanding-deleted
-    template<class U> constexpr T value_or(U&&) const &;
-    template<class U> constexpr T value_or(U&&) &&;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
 
     // \ref{optional.monadic}, monadic operations
     template<class F> constexpr auto and_then(F&& f) &;
@@ -3342,8 +3342,7 @@
 Any instance of \tcode{optional<T>} at any given time either contains a value or does not contain a value.
 When an instance of \tcode{optional<T>} \defnx{contains a value}{contains a value!\idxcode{optional}},
 it means that an object of type \tcode{T}, referred to as the optional object's \defnx{contained value}{contained value!\idxcode{optional}},
-is allocated within the storage of the optional object.
-Implementations are not permitted to use additional storage, such as dynamic memory, to allocate its contained value.
+is nested within\iref{intro.object} the optional object.
 When an object of type \tcode{optional<T>} is contextually converted to \tcode{bool},
 the conversion returns \tcode{true} if the object contains a value;
 otherwise the conversion returns \tcode{false}.
@@ -3504,7 +3503,7 @@
 
 \indexlibraryctor{optional}%
 \begin{itemdecl}
-template<class U = T> constexpr explicit(@\seebelow@) optional(U&& v);
+template<class U = remove_cv_t<T>> constexpr explicit(@\seebelow@) optional(U&& v);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3756,7 +3755,7 @@
 
 \indexlibrarymember{operator=}{optional}%
 \begin{itemdecl}
-template<class U = T> constexpr optional<T>& operator=(U&& v);
+template<class U = remove_cv_t<T>> constexpr optional& operator=(U&& v);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4193,7 +4192,7 @@
 
 \indexlibrarymember{value_or}{optional}%
 \begin{itemdecl}
-template<class U> constexpr T value_or(U&& v) const &;
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4211,7 +4210,7 @@
 
 \indexlibrarymember{value_or}{optional}%
 \begin{itemdecl}
-template<class U> constexpr T value_or(U&& v) &&;
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4659,6 +4658,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{U} is not a specialization of \tcode{optional}.
 The expression \tcode{*x == v} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
@@ -4678,6 +4678,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{T} is not a specialization of \tcode{optional}.
 The expression \tcode{v == *x} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4694,6 +4695,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{U} is not a specialization of \tcode{optional}.
 The expression \tcode{*x != v} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4710,6 +4712,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{T} is not a specialization of \tcode{optional}.
 The expression \tcode{v != *x} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4726,6 +4729,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{U} is not a specialization of \tcode{optional}.
 The expression \tcode{*x < v} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4742,6 +4746,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{T} is not a specialization of \tcode{optional}.
 The expression \tcode{v < *x} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4758,6 +4763,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{U} is not a specialization of \tcode{optional}.
 The expression \tcode{*x > v} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4774,6 +4780,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{T} is not a specialization of \tcode{optional}.
 The expression \tcode{v > *x} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4790,6 +4797,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{U} is not a specialization of \tcode{optional}.
 The expression \tcode{*x <= v} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4806,6 +4814,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{T} is not a specialization of \tcode{optional}.
 The expression \tcode{v <= *x} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4822,6 +4831,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{U} is not a specialization of \tcode{optional}.
 The expression \tcode{*x >= v} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -4838,6 +4848,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
+\tcode{T} is not a specialization of \tcode{optional}.
 The expression \tcode{v >= *x} is well-formed and
 its result is convertible to \tcode{bool}.
 
@@ -5132,10 +5143,9 @@
 of one of its alternative types or holds no value.
 When an instance of \tcode{variant} holds a value of alternative type \tcode{T},
 it means that a value of type \tcode{T}, referred to as the \tcode{variant}
-object's \defnx{contained value}{contained value!\idxcode{variant}}, is allocated within the storage of the
+object's \defnx{contained value}{contained value!\idxcode{variant}},
+is nested within\iref{intro.object} the
 \tcode{variant} object.
-Implementations are not permitted to use additional storage, such as dynamic
-memory, to allocate the contained value.
 
 \pnum
 All types in \tcode{Types} shall meet
@@ -7428,7 +7438,7 @@
     template<class U, class G>
       constexpr explicit(@\seebelow@) expected(expected<U, G>&&);
 
-    template<class U = T>
+    template<class U = remove_cv_t<T>>
       constexpr explicit(@\seebelow@) expected(U&& v);
 
     template<class G>
@@ -7451,7 +7461,7 @@
     // \ref{expected.object.assign}, assignment
     constexpr expected& operator=(const expected&);
     constexpr expected& operator=(expected&&) noexcept(@\seebelow@);
-    template<class U = T> constexpr expected& operator=(U&&);
+    template<class U = remove_cv_t<T>> constexpr expected& operator=(U&&);
     template<class G>
       constexpr expected& operator=(const unexpected<G>&);
     template<class G>
@@ -7483,8 +7493,8 @@
     constexpr E& error() & noexcept;
     constexpr const E&& error() const && noexcept;
     constexpr E&& error() && noexcept;
-    template<class U> constexpr T value_or(U&&) const &;
-    template<class U> constexpr T value_or(U&&) &&;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U&&) &&;
     template<class G = E> constexpr E error_or(G&&) const &;
     template<class G = E> constexpr E error_or(G&&) &&;
 
@@ -7527,10 +7537,8 @@
 \pnum
 Any object of type \tcode{expected<T, E>} either
 contains a value of type \tcode{T} or
-a value of type \tcode{E} within its own storage.
-Implementations are not permitted to use additional storage,
-such as dynamic memory,
-to allocate the object of type \tcode{T} or the object of type \tcode{E}.
+a value of type \tcode{E}
+nested within\iref{intro.object} it.
 Member \exposid{has_val} indicates whether the \tcode{expected<T, E>} object
 contains an object of type \tcode{T}.
 
@@ -7735,7 +7743,7 @@
 
 \indexlibraryctor{expected}%
 \begin{itemdecl}
-template<class U = T>
+template<class U = remove_cv_t<T>>
   constexpr explicit(!is_convertible_v<U, T>) expected(U&& v);
 \end{itemdecl}
 
@@ -8054,7 +8062,7 @@
 
 \indexlibrarymember{operator=}{expected}%
 \begin{itemdecl}
-template<class U = T>
+template<class U = remove_cv_t<T>>
   constexpr expected& operator=(U&& v);
 \end{itemdecl}
 
@@ -8422,7 +8430,7 @@
 
 \indexlibrarymember{value_or}{expected}%
 \begin{itemdecl}
-template<class U> constexpr T value_or(U&& v) const &;
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) const &;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -8438,7 +8446,7 @@
 
 \indexlibrarymember{value_or}{expected}%
 \begin{itemdecl}
-template<class U> constexpr T value_or(U&& v) &&;
+template<class U = remove_cv_t<T>> constexpr T value_or(U&& v) &&;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -8913,9 +8921,8 @@
 \pnum
 Any object of type \tcode{expected<T, E>} either
 represents a value of type \tcode{T}, or
-contains a value of type \tcode{E} within its own storage.
-Implementations are not permitted to use additional storage,
-such as dynamic memory, to allocate the object of type \tcode{E}.
+contains a value of type \tcode{E}
+nested within\iref{intro.object} it.
 Member \exposid{has_val} indicates whether the \tcode{expected<T, E>} object
 represents a value of type \tcode{T}.
 
@@ -9796,8 +9803,6 @@
   public:
     // bit reference
     class reference {
-      constexpr reference() noexcept;
-
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();