diff --git a/source/algorithms.tex b/source/algorithms.tex
index 6bcc0def0d..ce8246a973 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -1044,7 +1044,7 @@
 \tcode{InputIterator},
 \tcode{InputIterator1},
 or
-\tcode{InputIterator2},
+\tcode{Input\-Iterator2},
 the template argument shall satisfy the
 requirements of an input iterator~(\ref{input.iterators}).
 \item
@@ -1052,7 +1052,7 @@
 \tcode{OutputIterator},
 \tcode{OutputIterator1},
 or
-\tcode{OutputIterator2},
+\tcode{Output\-Iterator2},
 the template argument shall satisfy the requirements
 of an output iterator~(\ref{output.iterators}).
 \item
@@ -1060,7 +1060,7 @@
 \tcode{ForwardIterator},
 \tcode{ForwardIterator1},
 or
-\tcode{ForwardIterator2},
+\tcode{Forward\-Iterator2},
 the template argument shall satisfy the requirements
 of a forward iterator~(\ref{forward.iterators}).
 \item
@@ -3881,7 +3881,10 @@
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last}
+\returns
+\begin{codeblock}
+is_sorted_until(std::forward<ExecutionPolicy>(exec), first, last, comp) == last
+\end{codeblock}
 \end{itemdescr}
 
 
@@ -5206,7 +5209,7 @@
 \requires
 The value of \tcode{lo} shall be no greater than \tcode{hi}.
 For the first form, type \tcode{T}
-shall be \tcode{LessThanComparable} (Table~\ref{tab:lessthancomparable}).
+shall be \tcode{LessThan\-Comparable} (Table~\ref{tab:lessthancomparable}).
 
 \pnum
 \returns
diff --git a/source/atomics.tex b/source/atomics.tex
index dd55e136c7..47c44251d9 100644
--- a/source/atomics.tex
+++ b/source/atomics.tex
@@ -465,14 +465,22 @@
     operator @\placeholdernc{integral}@() const noexcept;
     @\placeholdernc{integral}@ exchange(@\placeholdernc{integral}@, memory_order = memory_order_seq_cst) volatile noexcept;
     @\placeholdernc{integral}@ exchange(@\placeholdernc{integral}@, memory_order = memory_order_seq_cst) noexcept;
-    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order, memory_order) noexcept;
-    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order, memory_order) noexcept;
-    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order = memory_order_seq_cst) volatile noexcept;
-    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order = memory_order_seq_cst) noexcept;
-    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order = memory_order_seq_cst) volatile noexcept;
-    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@, memory_order = memory_order_seq_cst) noexcept;
+    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                               memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                               memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                                 memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                                 memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                               memory_order = memory_order_seq_cst) volatile noexcept;
+    bool compare_exchange_weak(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                               memory_order = memory_order_seq_cst) noexcept;
+    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                               memory_order = memory_order_seq_cst) volatile noexcept;
+    bool compare_exchange_strong(@\placeholder{integral}@&,@\itcorr[-1]@ @\placeholdernc{integral}@,
+                               memory_order = memory_order_seq_cst) noexcept;
     @\placeholdernc{integral}@ fetch_add(@\placeholdernc{integral}@, memory_order = memory_order_seq_cst) volatile noexcept;
     @\placeholdernc{integral}@ fetch_add(@\placeholdernc{integral}@, memory_order = memory_order_seq_cst) noexcept;
     @\placeholdernc{integral}@ fetch_sub(@\placeholdernc{integral}@, memory_order = memory_order_seq_cst) volatile noexcept;
diff --git a/source/containers.tex b/source/containers.tex
index 4a32df312a..68863d5b0c 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -3209,8 +3209,8 @@
 
 \begin{itemdescr}
 \pnum \returns
-A pointer such that \range{data()}{data() + size()} is a valid range, and
-\tcode{data() == addressof(front())}.
+A pointer such that \tcode{data() == addressof(front())},
+and \range{data()}{data() + size()} is a valid range.
 \end{itemdescr}
 
 \rSec3[array.fill]{\tcode{array::fill}}
@@ -6338,7 +6338,7 @@
 \pnum
 \requires
 \tcode{is_assignable_v<mapped_type\&, M\&\&>} shall be \tcode{true}.
-\tcode{value_type} shall be \tcode{EmplaceConstructible} into \tcode{map}
+\tcode{value_type} shall be \tcode{Emplace\-Constructible} into \tcode{map}
 from \tcode{k}, \tcode{forward<M>(obj)}.
 
 \pnum
@@ -6373,7 +6373,7 @@
 \pnum
 \requires
 \tcode{is_assignable_v<mapped_type\&, M\&\&>} shall be \tcode{true}.
-\tcode{value_type} shall be \tcode{EmplaceConstructible} into \tcode{map}
+\tcode{value_type} shall be \tcode{Emplace\-Constructible} into \tcode{map}
 from \tcode{move(k)}, \tcode{forward<M>(obj)}.
 
 \pnum
@@ -7830,7 +7830,7 @@
 \pnum
 \requires
 \tcode{is_assignable_v<mapped_type\&, M\&\&>} shall be \tcode{true}.
-\tcode{value_type} shall be \tcode{EmplaceConstructible} into \tcode{unordered_map}
+\tcode{value_type} shall be \tcode{Emplace\-Constructible} into \tcode{unordered_map}
 from \tcode{k}, \tcode{forward<M>(obj)}.
 
 \pnum
@@ -7865,7 +7865,7 @@
 \pnum
 \requires
 \tcode{is_assignable_v<mapped_type\&, M\&\&>} shall be \tcode{true}.
-\tcode{value_type} shall be \tcode{EmplaceConstructible} into \tcode{unordered_map}
+\tcode{value_type} shall be \tcode{Emplace\-Constructible} into \tcode{unordered_map}
 from \tcode{move(k)}, \tcode{forward<M>(obj)}.
 
 \pnum
diff --git a/source/declarations.tex b/source/declarations.tex
index 113c3b08bf..2d583add5b 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -227,12 +227,12 @@
 
 \pnum
 A \grammarterm{nodeclspec-function-declaration} shall declare a
-constructor, destructor, or conversion function.  \footnote{The
+constructor, destructor, or conversion function.\footnote{The
 ``implicit int'' rule of C is no longer supported.}
 \begin{note}
 A \grammarterm{nodeclspec-function-declaration} can only be used in a
 \grammarterm{template-declaration}~(Clause~\ref{temp}),
-\grammarterm{explicit-instantiation}~(\ref{temp.explicit}), or
+\grammarterm{explicit-instantiation} (\ref{temp.explicit}), or
 \grammarterm{explicit-specialization}~(\ref{temp.expl.spec}).
 \end{note}
 
diff --git a/source/tables.tex b/source/tables.tex
index 4a08e0af68..b29ee1b439 100644
--- a/source/tables.tex
+++ b/source/tables.tex
@@ -387,7 +387,7 @@
 {
  \begin{LongTable}
  {#1}{#2}
- {x{.30\hsize}x{.68\hsize}}
+ {x{.30\hsize}x{.64\hsize}}
 }
 {
  \end{LongTable}
@@ -457,7 +457,7 @@
 {
  \begin{LongTable}
  {#1}{#2}
- {x{.35\hsize}x{.28\hsize}x{.30\hsize}}
+ {x{.35\hsize}x{.28\hsize}x{.29\hsize}}
 }
 {
  \end{LongTable}
diff --git a/source/utilities.tex b/source/utilities.tex
index ba52d664fe..38267bddf4 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -1937,11 +1937,14 @@
 \indexlibrarymember{get}{tuple}%
 \begin{itemdecl}
 template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...>>& get(tuple<Types...>& t) noexcept;
+  constexpr tuple_element_t<I, tuple<Types...>>&
+    get(tuple<Types...>& t) noexcept;
 template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...>>&& get(tuple<Types...>&& t) noexcept; // Note A
+  constexpr tuple_element_t<I, tuple<Types...>>&&
+    get(tuple<Types...>&& t) noexcept;        // Note A
 template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...>> const& get(const tuple<Types...>& t) noexcept; // Note B
+  constexpr tuple_element_t<I, tuple<Types...>> const&
+    get(const tuple<Types...>& t) noexcept;   // Note B
 template <size_t I, class... Types>
   constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&& t) noexcept; 
 \end{itemdecl}
@@ -2053,7 +2056,7 @@
 \pnum
 \requires  For all \tcode{i},
 where \tcode{0 <= i} and
-\tcode{i < sizeof...(TTypes)}, \tcode{get<i>(t) < get<i>(u)}
+\tcode{i < sizeof...(TTypes)}, both \tcode{get<i>(t) < get<i>(u)}
 and \tcode{get<i>(u) < get<i>(t)}
 are valid expressions returning types that are
 convertible to \tcode{bool}.
@@ -8587,8 +8590,12 @@
 
 \begin{itemdescr}
 \pnum
-\requires Let \tcode{\placeholder{CT}} denote \tcode{common_type_t<typename unique_ptr<T1, D1>::pointer,
-typename unique_ptr<T2, D2>::pointer>}. Then the specialization
+\requires Let \tcode{\placeholder{CT}} denote
+\begin{codeblock}
+common_type_t<typename unique_ptr<T1, D1>::pointer,
+              typename unique_ptr<T2, D2>::pointer>
+\end{codeblock}
+Then the specialization
 \tcode{less<\placeholder{CT}>} shall be a function object type~(\ref{function.objects}) that
 induces a strict weak ordering~(\ref{alg.sorting}) on the pointer values.
 
@@ -9072,7 +9079,7 @@
 
 \begin{itemdescr}
 \pnum\remarks This constructor shall not participate in overload resolution
-unless \tcode{unique_ptr<Y, D>::pointer} is convertible to \tcode{T*}.
+unless \tcode{unique_ptr<Y, D>::\brk{}pointer} is convertible to \tcode{T*}.
 
 \pnum
 \effects If \tcode{r.get() == nullptr}, equivalent to \tcode{shared_ptr()}.
@@ -9556,7 +9563,8 @@
 
 \pnum
 \postconditions \tcode{w.get() == const_cast<T*>(r.get())} and
-\tcode{w.use_count() == r.use_count()}, where \tcode{w} is the return value.
+\tcode{w.use_count() == r.use_count()},\newline
+where \tcode{w} is the return value.
 
 \pnum \begin{note} The seemingly equivalent expression
 \tcode{shared_ptr<T>(const_cast<T*>(r.get()))} will eventually result in
@@ -11798,8 +11806,8 @@
 \effects
 
 \begin{itemize}
-\item If \tcode{uses_allocator_v<T, inner_allocator_type>} is \tcode{false} and
-\tcode{is_constructible_v<T, Args...>} is \tcode{true}, calls
+\item If \tcode{uses_allocator_v<T, inner_allocator_type>} is \tcode{false} and\\
+\tcode{is_constructible_v<T, Args...>} is \tcode{true}, calls\\
 \textit{OUTERMOST_ALLOC_TRAITS}(\tcode{*this})\tcode{::construct(\\
 \textit{OUTERMOST}(*this), p, std::forward<Args>(args)...)}.
 
@@ -11837,7 +11845,7 @@
 following rules:
 
 \begin{itemize}
-\item If \tcode{uses_allocator_v<T1, inner_allocator_type>} is \tcode{false} and
+\item If \tcode{uses_allocator_v<T1, inner_allocator_type>} is \tcode{false} and\\
 \tcode{is_constructible_v<T1, Args1...>} is \tcode{true},
 then \tcode{xprime} is \tcode{x}.
 
@@ -11861,7 +11869,7 @@
 and constructs a \tcode{tuple} object \tcode{yprime} from \tcode{y} by the following rules:
 
 \begin{itemize}
-\item If \tcode{uses_allocator_v<T2, inner_allocator_type>} is \tcode{false} and
+\item If \tcode{uses_allocator_v<T2, inner_allocator_type>} is \tcode{false} and\\
 \tcode{is_constructible_v<T2,
 Args2...>} is \tcode{true}, then \tcode{yprime} is \tcode{y}.
 
@@ -11983,10 +11991,14 @@
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{a.outer_allocator() == b.outer_allocator()} if
-\tcode{sizeof...(InnerAllocs)} is zero;
-otherwise, \tcode{a.outer_allocator() == b.outer_allocator()}
-\tcode{\&\&} \tcode{a.inner_allocator() == b.inner_allocator()}.
+\returns If \tcode{sizeof...(InnerAllocs)} is zero,
+\begin{codeblock}
+a.outer_allocator() == b.outer_allocator()
+\end{codeblock}
+otherwise
+\begin{codeblock}
+a.outer_allocator() == b.outer_allocator() && a.inner_allocator() == b.inner_allocator()
+\end{codeblock}
 \end{itemdescr}
 
 \indexlibrarymember{operator"!=}{scoped_allocator_adaptor}%
@@ -13769,7 +13781,7 @@
 \requires \tcode{F} shall be \tcode{CopyConstructible}.
 
 \pnum
-\remarks This constructor shall not participate in overload resolution unless
+\remarks This constructor template shall not participate in overload resolution unless
 \tcode{F} is Lvalue-Callable~(\ref{func.wrap.func}) for argument types
 \tcode{ArgTypes...} and return type \tcode{R}.
 
@@ -14142,7 +14154,7 @@
 \pnum
 \throws
 Any exception thrown by the copy constructor of \tcode{RandomAccessIterator1},
-or by the default constructor, copy constructor, or the copy assignment operator of the value type of \tcode{RandomAccessIterator1},
+or by the default constructor, copy constructor, or the copy assignment operator of the value type of \tcode{RandomAccess\-Iterator1},
 or the copy constructor or \tcode{operator()} of \tcode{BinaryPredicate} or \tcode{Hash}.
 May throw \tcode{bad_alloc} if additional memory needed for internal data structures cannot be allocated.
 \end{itemdescr}
@@ -14242,7 +14254,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-The value type of \tcode{RandomAccessIterator1} shall meet the \tcode{DefaultConstructible}, \tcode{CopyConstructible}, and \tcode{CopyAssignable} requirements.
+The value type of \tcode{RandomAccessIterator1} shall meet the \tcode{DefaultConstructible}, \tcode{Copy\-Constructible}, and \tcode{CopyAssignable} requirements.
 
 \pnum
 \requires
@@ -14257,7 +14269,7 @@
 \pnum
 \throws
 Any exception thrown by the copy constructor of \tcode{RandomAccessIterator1},
-or by the default constructor, copy constructor, or the copy assignment operator of the value type of \tcode{RandomAccessIterator1}
+or by the default constructor, copy constructor, or the copy assignment operator of the value type of \tcode{RandomAccess\-Iterator1}
 or the copy constructor or \tcode{operator()} of \tcode{BinaryPredicate} or \tcode{Hash}.
 May throw \tcode{bad_alloc} if additional memory needed for internal data structures cannot be allocated.
 \end{itemdescr}
@@ -16621,18 +16633,18 @@
   inline namespace literals {
     inline namespace chrono_literals {
       // ~\ref{time.duration.literals}, suffixes for duration literals
-      constexpr chrono::hours                                 operator "" h(unsigned long long);
-      constexpr chrono::duration<@\unspec,@ ratio<3600, 1>> operator "" h(long double);
-      constexpr chrono::minutes                               operator "" min(unsigned long long);
-      constexpr chrono::duration<@\unspec,@ ratio<60, 1>>   operator "" min(long double);
-      constexpr chrono::seconds                               operator "" s(unsigned long long);
-      constexpr chrono::duration<@\unspec@> @\itcorr[-1]@                operator "" s(long double);
-      constexpr chrono::milliseconds                          operator "" ms(unsigned long long);
+      constexpr chrono::hours                                operator "" h(unsigned long long);
+      constexpr chrono::duration<@\unspec,@ ratio<3600,1>> operator "" h(long double);
+      constexpr chrono::minutes                              operator "" min(unsigned long long);
+      constexpr chrono::duration<@\unspec,@ ratio<60,1>>   operator "" min(long double);
+      constexpr chrono::seconds                              operator "" s(unsigned long long);
+      constexpr chrono::duration<@\unspec@> @\itcorr[-1]@               operator "" s(long double);
+      constexpr chrono::milliseconds                         operator "" ms(unsigned long long);
       constexpr chrono::duration<@\unspec,@ milli>          operator "" ms(long double);
-      constexpr chrono::microseconds                          operator "" us(unsigned long long);
-      constexpr chrono::duration<@\unspec,@ micro>          operator "" us(long double);
-      constexpr chrono::nanoseconds                           operator "" ns(unsigned long long);
-      constexpr chrono::duration<@\unspec,@ nano>           operator "" ns(long double);
+      constexpr chrono::microseconds                         operator "" us(unsigned long long);
+      constexpr chrono::duration<@\unspec,@ micro>         operator "" us(long double);
+      constexpr chrono::nanoseconds                          operator "" ns(unsigned long long);
+      constexpr chrono::duration<@\unspec,@ nano>          operator "" ns(long double);
     }
   }
 
@@ -17321,7 +17333,8 @@
 \indexlibrarymember{operator==}{duration}%
 \begin{itemdecl}
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+  constexpr bool operator==(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17332,7 +17345,8 @@
 \indexlibrarymember{operator"!=}{duration}%
 \begin{itemdecl}
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+  constexpr bool operator!=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17343,7 +17357,8 @@
 \indexlibrarymember{operator<}{duration}%
 \begin{itemdecl}
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator<(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+  constexpr bool operator<(const duration<Rep1, Period1>& lhs,
+                           const duration<Rep2, Period2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17354,7 +17369,8 @@
 \indexlibrarymember{operator<=}{duration}%
 \begin{itemdecl}
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+  constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17365,7 +17381,8 @@
 \indexlibrarymember{operator>}{duration}%
 \begin{itemdecl}
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator>(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+  constexpr bool operator>(const duration<Rep1, Period1>& lhs,
+                           const duration<Rep2, Period2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17376,7 +17393,8 @@
 \indexlibrarymember{operator>=}{duration}%
 \begin{itemdecl}
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+  constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17814,7 +17832,8 @@
 \indexlibrarymember{operator==}{time_point}%
 \begin{itemdecl}
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+  constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17825,7 +17844,8 @@
 \indexlibrarymember{operator"!=}{time_point}%
 \begin{itemdecl}
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+  constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17836,7 +17856,8 @@
 \indexlibrarymember{operator<}{time_point}%
 \begin{itemdecl}
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+  constexpr bool operator<(const time_point<Clock, Duration1>& lhs,
+                           const time_point<Clock, Duration2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17847,7 +17868,8 @@
 \indexlibrarymember{operator<=}{time_point}%
 \begin{itemdecl}
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+  constexpr bool operator<=(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17858,7 +17880,8 @@
 \indexlibrarymember{operator>}{time_point}%
 \begin{itemdecl}
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+  constexpr bool operator>(const time_point<Clock, Duration1>& lhs,
+                           const time_point<Clock, Duration2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17869,7 +17892,8 @@
 \indexlibrarymember{operator>=}{time_point}%
 \begin{itemdecl}
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
+  constexpr bool operator>=(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17893,7 +17917,10 @@
 unless \tcode{ToDuration} is a specialization of \tcode{duration}.
 
 \pnum
-\returns \tcode{time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))}.
+\returns
+\begin{codeblock}
+time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))
+\end{codeblock}
 \end{itemdescr}
 
 \indexlibrarymember{floor}{time_point}%
@@ -17984,7 +18011,8 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{system_clock::duration::min() < system_clock::duration::zero()} shall
-be \tcode{true}. \begin{note} This implies that \tcode{rep} is a signed type. \end{note}
+be \tcode{true}.\\
+\begin{note} This implies that \tcode{rep} is a signed type. \end{note}
 \end{itemdescr}
 
 \indexlibrarymember{to_time_t}{system_clock}%