diff --git a/source/algorithms.tex b/source/algorithms.tex
index 0a87d51fee..4ec98b46f9 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -6675,7 +6675,6 @@
 If we define \tcode{equiv(a, b)} as \tcode{!comp(a, b) \&\& !comp(b, a)},
 then the requirements are that \tcode{comp} and \tcode{equiv}
 both be transitive relations:
-
 \begin{itemize}
 \item \tcode{comp(a, b) \&\& comp(b, c)} implies \tcode{comp(a, c)}
 \item \tcode{equiv(a, b) \&\& equiv(b, c)} implies \tcode{equiv(a, c)}
@@ -7598,7 +7597,6 @@
   For the overload with an \tcode{ExecutionPolicy},
   \bigoh{N \log N} swaps and \bigoh{N} applications of the predicate.
 \end{itemize}
-
 \end{itemdescr}
 
 \indexlibraryglobal{stable_partition}%
@@ -8440,7 +8438,6 @@
 {heap with respect to comp and proj@heap with respect to \tcode{comp} and \tcode{proj}}
 for a comparator and projection \tcode{comp} and \tcode{proj}
 if its elements are organized such that:
-
 \begin{itemize}
 \item
   With \tcode{$N$ = b - a}, for all $i$, $0 < i < N$,
@@ -11000,7 +10997,6 @@
 \pnum
 Some algorithms in this subclause are constrained with the following
 exposition-only concepts:
-
 \begin{itemdecl}
 template<class I>
 concept @\defexposconcept{nothrow-input-iterator}@ = // \expos
diff --git a/source/basic.tex b/source/basic.tex
index 1262f66d25..7a924c525f 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -253,7 +253,6 @@
 namespace N { int d; }          // defines \tcode{N} and \tcode{N::d}
 namespace N1 = N;               // defines \tcode{N1}
 X anX;                          // defines \tcode{anX}
-
 \end{codeblock}
 whereas these are just declarations:
 \begin{codeblock}
@@ -722,7 +721,6 @@
 
 \pnum
 For the purposes of the preceding requirements:
-
 \begin{itemize}
 \item If \tcode{D} is a class with an implicitly-declared
 constructor\iref{class.default.ctor,class.copy.ctor},
@@ -4321,7 +4319,6 @@
 
 \pnum
 Comparing alignments is meaningful and provides the obvious results:
-
 \begin{itemize}
 \item Two alignments are equal when their numeric values are equal.
 \item Two alignments are different when their numeric values are not equal.
@@ -5692,7 +5689,6 @@
 
 \pnum
 Every integer type has an \term{integer conversion rank} defined as follows:
-
 \begin{itemize}
 \item No two signed integer types other than \keyword{char} and \tcode{\keyword{signed}
 \keyword{char}} (if \keyword{char} is signed) have the same rank, even if they have
@@ -6254,7 +6250,6 @@
 \item
 for some evaluation $X$, $A$ is dependency-ordered before $X$ and
 $X$ carries a dependency to $B$.
-
 \end{itemize}
 \begin{note}
 The relation ``is dependency-ordered before'' is analogous to
diff --git a/source/classes.tex b/source/classes.tex
index 0c9871cca1..eb0a4eccf6 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -1564,7 +1564,6 @@
 that is of class type (or array thereof),
 the constructor selected to copy/move that member is trivial;
 \end{itemize}
-
 \indextext{constructor!move!non-trivial}%
 otherwise the copy/move constructor is
 \defnx{non-trivial}{constructor!copy!nontrivial}.
@@ -3179,7 +3178,6 @@
 destructor and \tcode{N} has a non-trivial constructor (for instance, if they declare or inherit
 virtual functions), the active member of \tcode{u} can be safely switched from \tcode{m} to
 \tcode{n} using the destructor and placement \grammarterm{new-expression} as follows:
-
 \begin{codeblock}
 u.m.~M();
 new (&u.n) N;
@@ -3357,7 +3355,6 @@
 \indextext{multiple inheritance}%
 A list of base classes can be specified in a class definition using
 the notation:
-
 \begin{bnf}
 \nontermdef{base-clause}\br
     \terminal{:} base-specifier-list
@@ -5322,7 +5319,6 @@
 non-static data members can be specified by a
 \grammarterm{ctor-initializer},
 which has the form
-
 \begin{bnf}
 \nontermdef{ctor-initializer}\br
     \terminal{:} mem-initializer-list
@@ -5784,7 +5780,6 @@
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 \end{codeblock}
-
 \end{example}
 
 \rSec2[class.inhctor.init]{Initialization by inherited constructor}%
@@ -6434,7 +6429,6 @@
 A binary operator expression \tcode{a @ b} is
 \defnx{usable}{usable!binary operator expression}
 if either
-
 \begin{itemize}
 \item
 \tcode{a} or \tcode{b} is of class or enumeration type and
@@ -6555,7 +6549,6 @@
 of type \tcode{R}\iref{cmp.categories}
 of glvalues \tcode{a} and \tcode{b} of the same type
 is defined as follows:
-
 \begin{itemize}
 \item
 If \tcode{a <=> b} is usable\iref{class.compare.default} and
@@ -6654,7 +6647,6 @@
 of a possibly-empty list of $n$ comparison category types
 $\tcode{T}_0$, $\tcode{T}_1$, $\dotsc$, $\tcode{T}_{n-1}$
 is defined as follows:
-
 \begin{itemize}
 \item
 If at least one $\tcode{T}_i$ is \tcode{std::partial_ordering},
diff --git a/source/compatibility.tex b/source/compatibility.tex
index f95de0135c..fb94f7962e 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -2294,7 +2294,6 @@
 \effect
 The signatures of the following member functions changed from taking an
 \tcode{iterator} to taking a \tcode{const_iterator}:
-
 \begin{itemize}
 \item \tcode{insert(iter, val)} for \tcode{vector}, \tcode{deque}, \tcode{list},
 \tcode{set}, \tcode{multiset}, \tcode{map}, \tcode{multimap}
@@ -2366,7 +2365,6 @@
 Valid \CppIII{} code that relies on implicit boolean conversions will fail to
 compile with this revision of \Cpp{}. Such conversions occur in the
 following conditions:
-
 \begin{itemize}
 \item passing a value to a function that takes an argument of type \tcode{bool};
 \item using \tcode{operator==} to compare to \tcode{false} or \tcode{true};
@@ -3416,7 +3414,6 @@
 \pnum
 Header \libheaderref{cstring}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{strchr}
 \item \tcode{strpbrk}
@@ -3430,7 +3427,6 @@
 \pnum
 Header \libheaderref{cwchar}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{wcschr}
 \item \tcode{wcspbrk}
@@ -3455,7 +3451,6 @@
 \pnum
 Header \libheaderref{cstdlib}:
 The following functions have different behavior:
-
 \begin{itemize}
 \item \tcode{atexit}
 \item \tcode{exit}
diff --git a/source/concepts.tex b/source/concepts.tex
index 36b784d9d7..60351b43f4 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -150,7 +150,6 @@
 The following type \tcode{T} meets the explicitly stated syntactic requirements
 of concept \tcode{C} above but does not meet the additional implicit
 requirements:
-
 \begin{codeblock}
 struct T {
   bool operator==(const T&) const { return true; }
@@ -365,7 +364,6 @@
 such that \tcode{f()} is equality-preserving.
 Types \tcode{From} and \tcode{To} model \tcode{\libconcept{convertible_to}<From, To>}
 only if:
-
 \begin{itemize}
 \item
 \tcode{To} is not an object or reference-to-object type, or
@@ -373,7 +371,6 @@
 
 \item
 \tcode{FromR} is not a reference-to-object type, or
-
 \begin{itemize}
 \item
 If \tcode{FromR} is an rvalue reference to a non const-qualified type, the
@@ -486,7 +483,6 @@
 Users can customize the behavior of \libconcept{common_with} by specializing the
 \tcode{common_type} class template\iref{meta.trans.other}.
 \end{note}
-
 \end{itemdescr}
 
 \rSec2[concepts.arithmetic]{Arithmetic concepts}
@@ -540,12 +536,10 @@
 \end{itemize}
 \tcode{LHS} and \tcode{RHS} model
 \tcode{\libconcept{assignable_from}<LHS, RHS>} only if
-
 \begin{itemize}
 \item \tcode{addressof(lhs = rhs) == addressof(lcopy)}.
 
 \item After evaluating \tcode{lhs = rhs}:
-
 \begin{itemize}
 \item \tcode{lhs} is equal to \tcode{rcopy}, unless \tcode{rhs} is a non-const
 xvalue that refers to \tcode{lcopy}.
@@ -600,7 +594,6 @@
 \tcode{ranges::swap(E1, E2)} for subexpressions \tcode{E1}
 and \tcode{E2} is expression-equivalent to an expression
 \tcode{S} determined as follows:
-
 \begin{itemize}
 \item
   \tcode{S} is \tcode{(void)swap(E1, E2)}
@@ -808,7 +801,6 @@
 If \tcode{T} is an object type, then let \tcode{rv} be an rvalue of type
 \tcode{T} and \tcode{u2} a distinct object of type \tcode{T} equal to
 \tcode{rv}. \tcode{T} models \libconcept{move_constructible} only if
-
 \begin{itemize}
 \item After the definition \tcode{T u = rv;}, \tcode{u} is equal to \tcode{u2}.
 
@@ -835,7 +827,6 @@
 If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type
 \tcode{T} or \tcode{\keyword{const} T} or an rvalue of type \tcode{\keyword{const} T}.
 \tcode{T} models \libconcept{copy_constructible} only if
-
 \begin{itemize}
 \item After the definition \tcode{T u = v;},
 \tcode{u} is equal to \tcode{v}\iref{concepts.equality} and
@@ -843,7 +834,6 @@
 
 \item \tcode{T(v)} is equal to \tcode{v} and does not modify \tcode{v}.
 \end{itemize}
-
 \end{itemdescr}
 
 \rSec1[concepts.compare]{Comparison concepts}
@@ -882,7 +872,6 @@
 Let \tcode{e} be an expression such that
 \tcode{decltype((e))} is \tcode{T}.
 \tcode{T} models \exposconcept{boolean-testable-impl} only if:
-
 \begin{itemize}
 \item
 either \tcode{remove_cvref_t<T>} is not a class type, or
@@ -900,7 +889,6 @@
 \pnum
 A \defnadj{disqualifying}{parameter}
 is a function parameter whose declared type \tcode{P}
-
 \begin{itemize}
 \item
 is not dependent on a template parameter, and
@@ -948,7 +936,6 @@
 
 \pnum
 A \defnadj{disqualifying}{declaration} is
-
 \begin{itemize}
 \item
 a (non-template) function declaration that
@@ -1131,7 +1118,6 @@
 Given a type \tcode{T}, let \tcode{a}, \tcode{b}, and \tcode{c} be
 lvalues of type \tcode{const remove_reference_t<T>}.
 \tcode{T} models \libconcept{totally_ordered} only if
-
 \begin{itemize}
 \item Exactly one of \tcode{bool(a < b)}, \tcode{bool(a > b)}, or
       \tcode{bool(a == b)} is \tcode{true}.
@@ -1140,7 +1126,6 @@
 \item \tcode{bool(a <= b) == !bool(b < a)}.
 \item \tcode{bool(a >= b) == !bool(a < b)}.
 \end{itemize}
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -1339,7 +1324,6 @@
 and
 \tcode{equiv}
 both be transitive relations:
-
 \begin{itemize}
 \item
 \tcode{comp(a, b) \&\& comp(b, c)}
diff --git a/source/containers.tex b/source/containers.tex
index 02f68e9572..f5dde072ef 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -641,7 +641,6 @@
 \ref{vector.modifiers})
 all container types defined in this Clause meet
 the following additional requirements:
-
 \begin{itemize}
 \item
 If an exception is thrown by an
@@ -704,7 +703,6 @@
 Likewise, the extent to which an implementation determines that a type cannot be
 an allocator is unspecified, except that as a minimum a type \tcode{A} shall not qualify
 as an allocator unless it meets both of the following conditions:
-
 \begin{itemize}
 \item The \grammarterm{qualified-id} \tcode{A::value_type}
 is valid and denotes a type\iref{temp.deduct}.
@@ -928,7 +926,6 @@
 the terms below are defined as if \tcode{A} were
 \tcode{allocator<T>} --- no allocator object needs to be created
 and user specializations of \tcode{allocator<T>} are not instantiated:
-
 \begin{itemize}
 \item
 \tcode{T} is \defnx{\oldconcept{DefaultInsertable} into \tcode{X}}
@@ -3938,14 +3935,12 @@
 to
 \tcode{j}
 is positive, the following condition holds:
-
 \begin{codeblock}
 value_comp(*j, *i) == false
 \end{codeblock}
 
 \pnum
 For associative containers with unique keys the stronger condition holds:
-
 \begin{codeblock}
 value_comp(*i, *j) != false
 \end{codeblock}
@@ -5965,7 +5960,6 @@
 
 \pnum
 The following exposition-only alias template may appear in deduction guides for sequence containers:
-
 \begin{codeblock}
 template<class InputIterator>
   using @\placeholdernc{iter-value-type}@ = typename iterator_traits<InputIterator>::value_type;  // \expos
@@ -8158,7 +8152,6 @@
 appends \tcode{sz - size()} default-inserted elements to the
 sequence.
 If \tcode{sz <= size()}, equivalent to:
-
 \begin{codeblock}
 list<T>::iterator it = begin();
 advance(it, sz);
@@ -9372,13 +9365,11 @@
 \pnum
 \effects
 Exchanges the contents of \tcode{x} and \tcode{y} as if by:
-
 \begin{codeblock}
 bool b = x;
 x = y;
 y = b;
 \end{codeblock}
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -18154,7 +18145,6 @@
 \tcode{stack},
 the library provides the following formatter specialization
 where \tcode{\placeholder{adaptor-type}} is the name of the template:
-
 \indexlibraryglobal{formatter}%
 \begin{codeblock}
 namespace std {
@@ -22307,7 +22297,6 @@
 \pnum
 \result
 A type \tcode{OP} such that:
-
 \begin{itemize}
 \item
 \tcode{OP} meets the accessor policy requirements,
@@ -23018,7 +23007,6 @@
 \pnum
 For each function defined in subclause \ref{mdspan.sub} that
 takes a parameter pack named \tcode{slices} as an argument:
-
 \begin{itemize}
 \item let \tcode{index_type} be
   \begin{itemize}
@@ -23282,7 +23270,6 @@
 
 \pnum
 Let \tcode{SubExtents} be a specialization of \tcode{extents} such that:
-
 \begin{itemize}
 \item
 %FIXME: I think we want the count here, "number" is ambiguous.
@@ -23293,7 +23280,6 @@
 for each rank index $k$ of \tcode{Extents} such that
 \tcode{\placeholder{map-rank}[$k$] != dynamic_extent} is \tcode{true},
 \tcode{SubExt\-ents::static_extent(\placeholder{map-rank}[$k$])} equals:
-
   \begin{itemize}
   \item
   \tcode{Extents::static_extent($k$)}
@@ -23333,7 +23319,6 @@
 for each $k$
 for which \tcode{\placeholder{map-rank}[$k$] != dynamic_extent} is \tcode{true},
 \tcode{ext.extent(\placeholder{map-rank}[$k$])} equals:
-
 \begin{itemize}
 \item
 \tcode{$s_k$.extent == 0 ? 0 : 1 + (\exposid{de-ice}($s_k$.extent) - 1) / \exposid{de-ice}($s_k$.stride)}
diff --git a/source/declarations.tex b/source/declarations.tex
index 0cb68a672d..8d0c7714ca 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1515,7 +1515,6 @@
 specialization\iref{temp.expl.spec}, an explicit
 instantiation\iref{temp.explicit} or it has one of the following
 forms:
-
 \begin{ncsimplebnf}
 class-key \opt{attribute-specifier-seq} identifier \terminal{;}\br
 class-key \opt{attribute-specifier-seq} simple-template-id \terminal{;}
@@ -2332,7 +2331,6 @@
 
 \pnum
 Declarators have the syntax
-
 \begin{bnf}
 \nontermdef{declarator}\br
     ptr-declarator\br
@@ -4226,7 +4224,6 @@
 \tcode{g}
 will be called with the value
 \tcode{f(2)}:
-
 \begin{codeblock}
 int a = 1;
 int f(int);
@@ -4565,7 +4562,6 @@
 an object of type
 \tcode{T}
 means:
-
 \begin{itemize}
 \item
 If
@@ -4769,7 +4765,6 @@
 the initialization of the $j^\text{th}$ element.
 \item
 Otherwise, if the destination type is a (possibly cv-qualified) class type:
-
 \begin{itemize}
 \item
 If the initializer expression is a prvalue
@@ -5681,7 +5676,6 @@
 A reference to type ``\cvqual{cv1} \tcode{T1}'' is initialized by
 an expression of type ``\cvqual{cv2} \tcode{T2}'' as follows:%
 \indextext{binding!reference}
-
 \begin{itemize}
 \item
 If the reference is an lvalue reference and the initializer expression
@@ -6144,7 +6138,6 @@
 int k { };                          // initialize to 0
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -7096,7 +7089,6 @@
 where $\tcode{U}_i$ is an lvalue reference if
 the initializer is an lvalue and an rvalue reference otherwise,
 variables are introduced with unique names $\tcode{r}_i$ as follows:
-
 \begin{ncbnf}
 \placeholder{S} \terminal{U$_i$ r$_i$ =} initializer \terminal{;}
 \end{ncbnf}
@@ -7222,7 +7214,6 @@
   enum E : int {};              // error: redeclaration of enumeration
 };
 \end{codeblock}
-
 \end{example}
 \end{note}
 The \grammarterm{identifier} in an \grammarterm{enum-head-name}
@@ -7319,7 +7310,6 @@
 type is not fixed,
 the type of each enumerator prior to the closing brace is determined as
 follows:
-
 \begin{itemize}
 \item If an
 initializer is specified for an enumerator, the
@@ -7759,7 +7749,6 @@
 \pnum
 A \grammarterm{namespace-alias-definition} declares an alternate name for a
 namespace according to the following grammar:
-
 \begin{bnf}
 \nontermdef{namespace-alias}\br
         identifier
@@ -7914,7 +7903,6 @@
 In particular, the name of a variable, function or enumerator does not
 hide the name of a class or enumeration declared in a different
 namespace. For example,
-
 \begin{codeblock}
 namespace A {
   class X { };
@@ -8467,7 +8455,6 @@
 \pnum
 \link{Linkage}{basic.link} between \Cpp{} and  non-\Cpp{} code fragments can
 be achieved using a \grammarterm{linkage-specification}:
-
 \indextext{\idxgram{linkage-specification}}%
 \indextext{specification!linkage!\idxcode{extern}}%
 %
@@ -9390,7 +9377,6 @@
 to the declaration of a class or enumeration.
 An \grammarterm{attribute-argument-clause} may be present
 and, if present, shall have the form:
-
 \begin{ncbnf}
 \terminal{(} unevaluated-string \terminal{)}
 \end{ncbnf}
diff --git a/source/exceptions.tex b/source/exceptions.tex
index e998767433..d09592e041 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -89,7 +89,6 @@
     goto l2;        // OK
   }
 }
-
 \end{codeblock}
 \end{example}
 \indextext{\idxcode{goto}!and try block}%
@@ -541,12 +540,10 @@
 a \link{function pointer conversion}{conv.fctptr}
 \item%
 a \link{qualification conversion}{conv.qual}, or
-
 \end{itemize}
 
 \item
 the \grammarterm{handler} is of type \cv{}~\tcode{T} or \tcode{const T\&} where \tcode{T} is a pointer or pointer-to-member type and \tcode{E} is \tcode{std::nullptr_t}.
-
 \end{itemize}
 
 \begin{note}
@@ -1085,9 +1082,7 @@
 when a call to a \tcode{wait()}, \tcode{wait_until()}, or \tcode{wait_for()}
 function on a condition variable\iref{thread.condition.condvar,thread.condition.condvarany}
 fails to meet a postcondition.
-
 \end{itemize}
-
 \end{note}
 
 \pnum
diff --git a/source/expressions.tex b/source/expressions.tex
index ab480b90c2..7516ddcf19 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -457,7 +457,6 @@
 if and only if
 the expression is a glvalue of volatile-qualified type and it is one of the
 following:
-
 \begin{itemize}
 \item \tcode{(} \grammarterm{expression} \tcode{)}, where
 \grammarterm{expression} is one of these expressions,
@@ -500,7 +499,6 @@
 \ref{conv} enumerates the full set of such conversions. A
 \defnx{standard conversion sequence}{conversion sequence!standard} is a sequence of standard
 conversions in the following order:
-
 \begin{itemize}
 \item Zero or one conversion from the following set: lvalue-to-rvalue
 conversion, array-to-pointer conversion, and function-to-pointer
@@ -528,7 +526,6 @@
 \begin{note}
 Expressions with a given type will be implicitly converted to other
 types in several contexts:
-
 \begin{itemize}
 \item When used as operands of operators. The operator's requirements
 for its operands dictate the destination type\iref{expr.compound}.
@@ -654,7 +651,6 @@
 \pnum
 The result of the conversion is determined according to the
 following rules:
-
 \begin{itemize}
 
 \item If \tcode{T} is \cv{}~\tcode{std::nullptr_t}, the result is a
@@ -1139,7 +1135,6 @@
 purpose is to yield a common type, which is also the type of the result.
 This pattern is called the \defnx{usual arithmetic conversions}{conversion!usual arithmetic},
 which are defined as follows:
-
 \begin{itemize}
 \item The lvalue-to-rvalue conversion\iref{conv.lval}
 is applied to each operand and
@@ -1182,7 +1177,6 @@
 to some integral type.
 \end{footnote}
 Then the following rules are applied to determine \tcode{C}:
-
 \begin{itemize}
 
 \item If \tcode{T1} and \tcode{T2} are the same type, \tcode{C} is that type.
@@ -2438,7 +2432,6 @@
 \pnum
 For the purposes of lambda capture,
 an expression potentially references local entities as follows:
-
 \begin{itemize}
 \item
 An \grammarterm{id-expression} that names a local entity
@@ -3041,7 +3034,6 @@
 of the \grammarterm{expression} $E$. Substitution
 of template arguments (if any) and verification of
 semantic properties proceed in the following order:
-
 \begin{itemize}
 \item
 Substitution of template arguments (if any)
@@ -3053,7 +3045,6 @@
 
 \item
 If the \grammarterm{return-type-requirement} is present, then:
-
 \begin{itemize}
 \item
 Substitution of template arguments (if any)
@@ -3669,7 +3660,6 @@
 otherwise \tcode{E1.E2} designates the object or function to which
 the corresponding reference member of \tcode{E1} is bound.
 Otherwise, one of the following rules applies.
-
 \begin{itemize}
 \item If \tcode{E2} is a static data member and the type of \tcode{E2}
 is \tcode{T}, then \tcode{E1.E2} is an lvalue; the expression designates
@@ -3866,7 +3856,6 @@
 \pnum
 Let \tcode{C} be the class type to which \tcode{T} points or refers. The runtime
 check logically executes as follows:
-
 \begin{itemize}
 \item If, in the most derived object pointed (referred) to by \tcode{v},
 \tcode{v} points (refers) to a public base class subobject of a
@@ -4418,7 +4407,6 @@
 The null member pointer value\iref{conv.mem} is converted to the
 null member pointer value of the destination type. The result of this
 conversion is unspecified, except in the following cases:
-
 \begin{itemize}
 \item Converting a prvalue of type ``pointer to member function'' to a
 different pointer-to-member-function type and back to its original type
@@ -4833,7 +4821,6 @@
 \pnum
 Evaluation of an \grammarterm{await-expression} involves the following
 auxiliary types, expressions, and objects:
-
 \begin{itemize}
 \item
 \placeholder{p} is an lvalue naming the promise
@@ -5214,7 +5201,6 @@
 the \grammarterm{new-expression}, then the allocated type is the type
 deduced for the variable \tcode{x} in the invented
 declaration\iref{dcl.spec.auto}:
-
 \begin{codeblock}
 T x @\textrm{\placeholder{init}}@ ;
 \end{codeblock}
@@ -5562,7 +5548,6 @@
 otherwise, an argument that
 is the type's alignment and has type \tcode{std::align_val_t}
 is added into the argument list immediately after the first argument;
-
 \end{itemize}
 and then overload resolution is performed again.
 
@@ -5640,7 +5625,6 @@
 \indextext{\idxcode{new}!default constructor and}%
 A \grammarterm{new-expression} that creates an object of type \tcode{T}
 initializes that object as follows:
-
 \begin{itemize}
 \item If the \grammarterm{new-initializer} is omitted, the object is
 default-initialized\iref{dcl.init}.
@@ -5729,7 +5713,6 @@
 S* p = new (0) S;   // error: non-placement deallocation function matches
                     // placement allocation function
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -5861,7 +5844,6 @@
 \pnum
 If the value of the operand of the \grammarterm{delete-expression} is not a
 null pointer value, then:
-
 \begin{itemize}
 \item
 If the allocation call for the \grammarterm{new-expression} for the object to
@@ -6485,7 +6467,6 @@
 the other operand has unscoped enumeration type,
 the \link{usual arithmetic conversions}{expr.arith.conv} are applied to the operands.
 Then:
-
 \begin{itemize}
 \item
 If a \deflinkx{narrowing conversion}{conversion!narrowing}{dcl.init.list} is required,
@@ -6642,7 +6623,6 @@
 $n$ for this purpose.
 \end{footnote}
 is defined in terms of a partial order consistent with the following rules:
-
 \begin{itemize}
 \item If two pointers point to different elements of the same array, or to
 subobjects thereof, the pointer to the element with the higher subscript
@@ -6655,7 +6635,6 @@
 and their class is not a union.
 
 \item Otherwise, neither pointer is required to compare greater than the other.
-
 \end{itemize}
 
 \pnum
@@ -6719,7 +6698,6 @@
 \link{qualification conversions}{conv.qual}
 are performed on both operands to bring them to their \deflink{composite pointer type}{expr.type}.
 Comparing pointers is defined as follows:
-
 \begin{itemize}
 \item
 If one pointer represents the address of a complete object, and another
@@ -6749,7 +6727,6 @@
 are performed on both operands to bring them to
 their composite pointer type\iref{expr.type}.
 Comparing pointers to members is defined as follows:
-
 \begin{itemize}
 \item
 If two pointers to members are both the null member pointer value, they compare
@@ -7021,7 +6998,6 @@
 from an operand expression \tcode{E1} of type \tcode{T1}
 to a target type related to the type \tcode{T2}
 of the operand expression \tcode{E2} as follows:
-
 \begin{itemize}
 \item If \tcode{E2} is an lvalue, the target type is
 ``lvalue reference to \tcode{T2}'',
@@ -7092,7 +7068,6 @@
 and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the second and third operands. After those conversions, one
 of the following shall hold:
-
 \begin{itemize}
 \item The second and third operands have the same type; the result is of
 that type and the result object is initialized using the selected operand.
@@ -7120,7 +7095,6 @@
 Both the second and third operands have type \tcode{std::nullptr_t} or one has
 that type and the other is a null pointer constant. The result is of type
 \tcode{std::nullptr_t}.
-
 \end{itemize}
 
 \rSec2[expr.yield]{Yielding a value}%
diff --git a/source/future.tex b/source/future.tex
index 26366b5732..2e3a0e4a5c 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -249,7 +249,6 @@
 
 \pnum
 The header \libheaderref{utility} has the following additions:
-
 \begin{codeblock}
 namespace std::rel_ops {
   template<class T> bool operator!=(const T&, const T&);
@@ -263,7 +262,6 @@
 To avoid redundant definitions of \tcode{operator!=} out of \tcode{operator==}
 and operators \tcode{>}, \tcode{<=}, and \tcode{>=} out of \tcode{operator<},
 the library provides the following:
-
 \indexlibrary{\idxcode{operator"!=}}%
 \begin{itemdecl}
 template<class T> bool operator!=(const T& x, const T& y);
@@ -365,7 +363,6 @@
 \pnum
 The header \libheaderrefx{type_traits}{meta.type.synop}
 has the following addition:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct is_pod;
@@ -488,7 +485,6 @@
 
 \pnum
 The header \libheaderref{tuple} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct tuple_size<volatile T>;
@@ -558,7 +554,6 @@
 
 \pnum
 The header \libheaderref{variant} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct variant_size<volatile T>;
@@ -605,7 +600,6 @@
 
 \pnum
 The header \libheaderrefx{iterator}{iterator.synopsis} has the following addition:
-
 \indexlibraryglobal{iterator}%
 \begin{codeblock}
 namespace std {
@@ -639,7 +633,6 @@
 If a \Cpp{} program wants to define a bidirectional iterator for some data
 structure containing \tcode{double} and such that it works on a large memory
 model of the implementation, it can do so with:
-
 \begin{codeblock}
 class MyIterator :
   public iterator<bidirectional_iterator_tag, double, long, T*, T&> {
@@ -653,7 +646,6 @@
 \pnum
 The following member is declared in addition to those members
 specified in \ref{move.iter.elem}:
-
 \begin{codeblock}
 namespace std {
   template<class Iterator>
@@ -681,7 +673,6 @@
 
 \pnum
 The header \libheaderref{format}{format.syn} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class Visitor, class Context>
@@ -746,7 +737,6 @@
 
 \pnum
 The header \libheaderrefx{filesystem}{fs.filesystem.syn} has the following additions:
-
 \indexlibraryglobal{u8path}%
 \begin{itemdecl}
 template<class Source>
@@ -827,7 +817,6 @@
 
 \pnum
 The header \libheaderrefx{atomic}{atomics.syn} has the following additions.
-
 \begin{codeblock}
 namespace std {
   template<class T>
diff --git a/source/iostreams.tex b/source/iostreams.tex
index f67d7df0dc..3fd5a38ecf 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -2110,14 +2110,12 @@
 Otherwise assigns to the member objects of
 \tcode{*this}
 the corresponding member objects of \tcode{rhs} as follows:
-
 \begin{itemize}
 \item calls each registered callback pair \tcode{(fn, idx)} as
 \tcode{(*fn)(erase_event, *this, idx)};
 
 \item then, assigns to the member objects of \tcode{*this} the corresponding member objects of
 \tcode{rhs}, except that
-
 \begin{itemize}
 \item \tcode{rdstate()}, \tcode{rdbuf()}, and \tcode{exceptions()} are left unchanged;
 
@@ -7203,7 +7201,6 @@
 format flags stored in the \tcode{basic_ostream<charT, traits>} object
 \tcode{cout} (the same as \tcode{cout << noshowbase}).
 \end{footnote}
-
 \begin{codeblock}
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
@@ -7242,7 +7239,6 @@
 behaves as if it called
 \tcode{f(in, mask)}, where the function \tcode{f} is defined as:
 \indexlibrarymember{fmtflags}{ios_base}%
-
 \begin{codeblock}
 void f(ios_base& str, ios_base::fmtflags mask) {
   // set specified flags
@@ -7288,7 +7284,6 @@
 \tcode{in >> setbase(base)}
 behaves as if it called
 \tcode{f(in, base)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 void f(ios_base& str, int base) {
   // set \tcode{basefield}
@@ -7331,7 +7326,6 @@
 \tcode{out << setfill(c)}
 behaves as if it called
 \tcode{f(out, c)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits>
 void f(basic_ios<charT, traits>& str, charT c) {
@@ -7372,7 +7366,6 @@
 \tcode{in >> setprecision(n)}
 behaves as if it called
 \tcode{f(in, n)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 void f(ios_base& str, int n) {
   // set precision
@@ -7418,7 +7411,6 @@
 \tcode{in >> setw(n)}
 behaves as if it called
 \tcode{f(in, n)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 void f(ios_base& str, int n) {
   // set width
@@ -7468,7 +7460,6 @@
 \tcode{in} is an object of type \tcode{basic_istream<charT, traits>}
 then the expression \tcode{in >> get_money(mon, intl)} behaves as if it called
 \tcode{f(in, mon, intl)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
@@ -7507,7 +7498,6 @@
 then the expression \tcode{out << put_money(mon, intl)} behaves as a
 \link{formatted output function}{ostream.formatted.reqmts} that calls
 \tcode{f(out, mon, intl)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
@@ -7543,7 +7533,6 @@
 \tcode{basic_istream<charT, traits>} then the expression \tcode{in >> get_time(tmb,
 fmt)} behaves as if it called \tcode{f(in, tmb, fmt)}, where the function \tcode{f} is
 defined as:
-
 \begin{codeblock}
 template<class charT, class traits>
 void f(basic_ios<charT, traits>& str, tm* tmb, const charT* fmt) {
@@ -7582,7 +7571,6 @@
 type \tcode{basic_ostream<charT, traits>} then the expression
 \tcode{out << put_time(tmb, fmt)} behaves as if it called \tcode{f(out, tmb, fmt)},
 where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits>
 void f(basic_ios<charT, traits>& str, const tm* tmb, const charT* fmt) {
@@ -11406,7 +11394,6 @@
 sequence as if by reading from the associated file
 into an internal buffer (\tcode{extern_buf})
 and then as if by doing:
-
 \begin{codeblock}
 char   extern_buf[XSIZE];
 char*  extern_end;
@@ -13888,7 +13875,6 @@
 \pnum
 \indextext{path!normalization|(}%
 \defnx{Normalization}{normalization!path} of a generic format pathname means:
-
 \begin{enumerate}
 \item If the path is empty, stop.
 \item Replace each slash character in the \grammarterm{root-name} with a \grammarterm{preferred-separator}.
@@ -17010,7 +16996,6 @@
 As specified for the prefix increment operation of
 \link{Input iterators}{input.iterators},
 except that:
-
 \begin{itemize}
 \item If there are no more  entries at the current depth, then if \tcode{depth() != 0}
 iteration over the parent directory resumes; otherwise \tcode{*this = recursive_directory_iterator()}.
diff --git a/source/iterators.tex b/source/iterators.tex
index 377b95bf04..01b970b6c9 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -933,7 +933,6 @@
 \pnum
 The definitions in this subclause make use of the following
 exposition-only concepts:
-
 \begin{codeblock}
 template<class I>
 concept @\defexposconcept{cpp17-iterator}@ =
@@ -991,7 +990,6 @@
 \pnum
 The members of a specialization \tcode{iterator_traits<I>} generated from the
 \tcode{iterator_traits} primary template are computed as follows:
-
 \begin{itemize}
 \item
 If \tcode{I} has valid\iref{temp.deduct} member
@@ -1140,7 +1138,6 @@
 a customization point object\iref{customization.point.object}.
 The expression \tcode{ranges::\-iter_move(E)} for a subexpression \tcode{E} is
 expression-equivalent to:
-
 \begin{itemize}
 \item \tcode{iter_move(E)}, if
 \tcode{E} has class or enumeration type and
@@ -2785,7 +2782,6 @@
 A program-defined iterator \tcode{BinaryTreeIterator}
 can be included into the bidirectional iterator category by
 specializing the \tcode{iterator_traits} template:
-
 \begin{codeblock}
 template<class T> struct iterator_traits<BinaryTreeIterator<T>> {
   using iterator_category = bidirectional_iterator_tag;
@@ -2803,7 +2799,6 @@
 \tcode{evolve()}
 is well-defined for bidirectional iterators, but can be implemented more
 efficiently for random access iterators, then the implementation is as follows:
-
 \begin{codeblock}
 template<class BidirectionalIterator>
 inline void
@@ -3411,7 +3406,6 @@
 Iterator tmp = current;
 return *--tmp;
 \end{codeblock}
-
 \end{itemdescr}
 
 \indexlibrarymember{operator->}{reverse_iterator}%
@@ -4787,7 +4781,6 @@
 vector<string> v2(make_move_iterator(s.begin()),
                   make_move_iterator(s.end())); // moves strings into \tcode{v2}
 \end{codeblock}
-
 \end{example}
 
 \rSec3[move.iterator]{Class template \tcode{move_iterator}}
@@ -6506,7 +6499,6 @@
   istream_iterator<double, char>(),
   ostream_iterator<double, char>(cout, "@\textbackslash@n"));
 \end{codeblock}
-
 reads a file containing floating-point numbers from
 \tcode{cin},
 and prints the partial sums onto
diff --git a/source/lex.tex b/source/lex.tex
index 3186da9f7c..0340b59647 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -552,7 +552,6 @@
 
 \item
 within a \grammarterm{has-include-expression}.
-
 \end{itemize}
 \end{itemize}
 
@@ -1036,7 +1035,6 @@
 The lexical representation of \Cpp{} programs includes a number of
 preprocessing tokens that are used in the syntax of the preprocessor or
 are converted into tokens for operators and punctuators:
-
 \begin{bnf}
 \nontermdef{preprocessing-op-or-punc}\br
     preprocessing-operator\br
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 13c8d650d9..f3a779a79a 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -194,7 +194,6 @@
 For example, if a Clause does not specify any requirements,
 there will be no ``Requirements'' subclause.
 \end{footnote}
-
 \begin{itemize}
 \item Summary
 \item Requirements
@@ -211,7 +210,6 @@
 
 \pnum
 The contents of the summary and the detailed specifications include:
-
 \begin{itemize}
 \item macros
 \item values
@@ -228,7 +226,6 @@
 \indextext{requirements}%
 Requirements describe constraints that shall be met by a \Cpp{} program that extends the standard library.
 Such extensions are generally one of the following:
-
 \begin{itemize}
 \item Template arguments
 \item Derived classes
@@ -303,7 +300,6 @@
 
 \pnum
 The detailed specifications each contain the following elements:%
-
 \begin{itemize}
 \item name and brief description
 \item synopsis (class definition or function declaration, as appropriate)
@@ -320,7 +316,6 @@
 For example, if a class does not specify any comparison operator functions, there
 will be no ``Comparison operator functions'' subclause.
 \end{footnote}
-
 \begin{itemize}
 \item constructor(s) and destructor
 \item copying, moving \& assignment functions
@@ -338,7 +333,6 @@
 For example, if a function specifies no
 preconditions, there will be no \expects element.
 \end{footnote}
-
 \begin{itemize}
 \item
 \constraints
@@ -566,7 +560,6 @@
 
 \pnum
 The enumerated type \tcode{\placeholder{enumerated}} can be written:
-
 \begin{codeblock}
 enum @\placeholder{enumerated}@ { @$\tcode{\placeholder{V}}_{0}$@, @$\tcode{\placeholder{V}}_{1}$@, @$\tcode{\placeholder{V}}_{2}$@, @$\tcode{\placeholder{V}}_{3}$@, @$\ldots$@ };
 
@@ -599,7 +592,6 @@
 
 \pnum
 The bitmask type \tcode{\placeholder{bitmask}} can be written:
-
 \begin{codeblock}
 // For exposition only.
 // \tcode{int_type} is an integral type capable of representing all values of the bitmask type.
@@ -676,7 +668,6 @@
 The C standard library makes widespread use
 \indextext{library!C standard}%
 of characters and character sequences that follow a few uniform conventions:
-
 \begin{itemize}
 \item
 Properties specified as \defn{locale-specific}
@@ -881,7 +872,6 @@
 private members of classes that meet the external specifications of the classes.
 The declarations for such members are
 followed by a comment that ends with \expos, as in:
-
 \begin{codeblock}
 streambuf* sb;      // \expos
 \end{codeblock}
@@ -1828,7 +1818,6 @@
 evaluated in the context described below, and
 
 \item these expressions have the following effects:
-
 \begin{itemize}
 \item the object referred to by \tcode{t} has the value originally held by \tcode{u} and
 \item the object referred to by \tcode{u} has the value originally held by \tcode{t}.
@@ -2834,7 +2823,6 @@
 \begin{example}
 The following is an allocator class template supporting the minimal
 interface that meets the requirements of \ref{allocator.requirements.general}:
-
 \begin{codeblock}
 template<class T>
 struct SimpleAllocator {
@@ -3298,7 +3286,6 @@
 A \Cpp{} program may provide the definition for any of the following
 dynamic memory allocation function signatures declared in header
 \tcode{<new>}\iref{basic.stc.dynamic,new.syn}:
-
 \indextext{\idxcode{new}!\idxcode{operator}!replaceable}%
 \indexlibrarymember{new}{operator}%
 \begin{codeblock}
@@ -3357,7 +3344,6 @@
 \pnum
 The \Cpp{} standard library provides a default version of the following handler
 function\iref{support}:
-
 \begin{itemize}
 \item
 \tcode{terminate_handler}
@@ -3378,7 +3364,6 @@
 \pnum
 A \Cpp{} program can get a pointer to the current handler function by calling the following
 functions:
-
 \begin{itemize}
 \item
 \indexlibraryglobal{get_new_handler}%
@@ -3404,7 +3389,6 @@
 
 \pnum
 In particular, the behavior is undefined in the following cases:
-
 \begin{itemize}
 \item
 For replacement functions\iref{new.delete}, if the installed replacement function does not
@@ -3683,7 +3667,6 @@
 \indextext{stable algorithm}%
 When the requirements for an algorithm state that it is ``stable'' without further elaboration,
 it means:
-
 \begin{itemize}
 \item For the sort algorithms the relative order of equivalent
 elements is preserved.
diff --git a/source/limits.tex b/source/limits.tex
index 8b9df48e05..8bf6632ca5 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -134,5 +134,4 @@
 Number of \link{placeholders}{func.bind.place} [10].
 \item%
 Number of hazard-protectable possibly-reclaimable objects\iref{saferecl.hp.general} [256].
-
 \end{itemize}
diff --git a/source/locales.tex b/source/locales.tex
index ef1a6c6538..6c3f2b6635 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -186,7 +186,6 @@
 the stream is implicitly converted
 to an \tcode{ostreambuf_iterator<charT, traits>}.
 \end{footnote}
-
 \begin{codeblock}
 template<class charT, class traits>
 basic_ostream<charT, traits>&
@@ -221,7 +220,6 @@
 All locale semantics are accessed via
 \tcode{use_facet<>} and \tcode{has_facet<>},
 except that:
-
 \begin{itemize}
 \item
 A member operator template
@@ -756,7 +754,6 @@
 A vector of strings \tcode{v}
 can be collated according to collation rules in locale \tcode{loc}
 simply by\iref{alg.sort,vector}:
-
 \begin{codeblock}
 std::sort(v.begin(), v.end(), loc);
 \end{codeblock}
@@ -2213,7 +2210,6 @@
 
 \pnum
 The details of this operation occur in three stages
-
 \begin{itemize}
 \item
 Stage 1:
@@ -2336,7 +2332,6 @@
 The sequence of \tcode{char}{s} accumulated in stage 2 (the field)
 is converted to a numeric value by the rules of one of the functions
 declared in the header \libheader{cstdlib}:
-
 \begin{itemize}
 \item
 For a signed integer value, the function \tcode{strtoll}.
@@ -2370,7 +2365,6 @@
 If the conversion function does not convert the entire field, or
 if the field represents a value outside the range of representable values,
 \tcode{ios_base::failbit} is assigned to \tcode{err}.
-
 \end{description}
 
 \pnum
@@ -2538,7 +2532,6 @@
 
 \pnum
 The details of this operation occur in several stages:
-
 \begin{itemize}
 \item
 Stage 1:
@@ -3353,7 +3346,6 @@
 reading zero or more characters from \tcode{s} at each iteration.
 Unless otherwise specified below,
 the loop terminates when the first of the following conditions holds:
-
 \begin{itemize}
 \item
 The expression \tcode{fmt == fmtend} evaluates to \tcode{true}.
@@ -4165,7 +4157,6 @@
 The symbol \locgrammarterm{decimal-point}
 indicates the character returned by \tcode{decimal_point()}.
 The other symbols are defined as follows:
-
 \begin{ncbnf}
 \locnontermdef{units}\br
     digits\br
diff --git a/source/memory.tex b/source/memory.tex
index 1a80d14ed0..2808a11c65 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -1275,7 +1275,6 @@
 
 \pnum
 Let \exposid{pair-constructor} be an exposition-only class defined as follows:
-
 \begin{codeblock}
 class @\exposid{pair-constructor}@ {
   using @\exposid{pair-type}@ = remove_cv_t<T>;                             // \expos
@@ -3375,7 +3374,6 @@
 \tcode{is_move_constructible_v<D>} is \tcode{true}, and
 \tcode{d(p)} is a well-formed expression.
 For the first two overloads:
-
 \begin{itemize}
 \item
 If \tcode{T} is an array type, then either
diff --git a/source/meta.tex b/source/meta.tex
index 17cbbf91dd..9ceef568c3 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -1582,7 +1582,6 @@
 The predicate condition for a template specialization \tcode{is_convertible<From, To>}
 shall be satisfied if and only if the return expression in the following code would be
 well-formed, including any implicit conversions to the return type of the function:
-
 \begin{codeblock}
 To test() {
   return declval<From>();
@@ -2069,7 +2068,6 @@
 Note A:
 For the \tcode{common_type} trait applied to a template parameter pack \tcode{T} of types,
 the member \tcode{type} shall be either defined or not present as follows:
-
 \begin{itemize}
 \item If \tcode{sizeof...(T)} is zero, there shall be no member \tcode{type}.
 
diff --git a/source/numerics.tex b/source/numerics.tex
index c8c87fa31d..5f6c48a33f 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -615,7 +615,6 @@
 \pnum
 \returns
 \tcode{complex<T>(lhs)}.
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -754,7 +753,6 @@
 \effects
 Inserts the complex number \tcode{x}
 onto the stream \tcode{o} as if it were implemented as follows:
-
 \begin{codeblock}
 basic_ostringstream<charT, traits> s;
 s.flags(o.flags());
@@ -3930,7 +3928,6 @@
  each operation is to be carried out modulo $2^{32}$,
  each indexing operator applied to \tcode{begin} is to be taken modulo $n$,
  and $T(x)$ is defined as $x \xor (x \rightshift 27)$:
-
 \begin{itemize}
  \item
    By way of initialization,
@@ -7977,7 +7974,6 @@
 to an operand of type \tcode{T}.
 This function returns a value of type \tcode{T}
 or which can be unambiguously implicitly converted to type \tcode{T}.
-
 \end{itemdescr}
 
 \rSec3[valarray.special]{Specialized algorithms}
@@ -7993,7 +7989,6 @@
 Equivalent to \tcode{x.swap(y)}.
 \end{itemdescr}
 
-
 \rSec2[class.slice]{Class \tcode{slice}}
 
 \rSec3[class.slice.overview]{Overview}
@@ -8413,7 +8408,6 @@
 This template is a helper template used by the
 \tcode{gslice}
 subscript operator
-
 \indexlibraryglobal{gslice_array}%
 \indexlibraryglobal{valarray}%
 \begin{itemdecl}
@@ -8539,7 +8533,6 @@
 
 \pnum
 This template is a helper template used by the mask subscript operator:
-
 \indexlibrarymember{operator[]}{mask_array}%
 \begin{itemdecl}
 mask_array<T> valarray<T>::operator[](const valarray<bool>&);
@@ -8656,7 +8649,6 @@
 
 \pnum
 This template is a helper template used by the indirect subscript operator
-
 \indexlibrarymember{operator[]}{indirect_array}%
 \begin{itemdecl}
 indirect_array<T> valarray<T>::operator[](const valarray<size_t>&);
@@ -10130,7 +10122,6 @@
 \]
 where
 $x$ is \tcode{x}.
-
 \end{itemdescr}
 
 \rSec3[sf.cmath.hermite]{Hermite polynomials}%
diff --git a/source/overloading.tex b/source/overloading.tex
index 6bf3bbe172..6c5d37f270 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -98,7 +98,6 @@
 But, once the
 candidate functions and argument lists have been identified, the
 selection of the best function is the same in all cases:
-
 \begin{itemize}
 \item
 First, a subset of the candidate functions (those that have
@@ -391,7 +390,6 @@
 \grammarterm{postfix-expression},
 perhaps nested arbitrarily deep in
 parentheses, has one of the following forms:
-
 \begin{ncbnf}
 postfix-expression:\br
     postfix-expression \terminal{.} id-expression\br
@@ -972,7 +970,6 @@
 the lookup
 rules for operator function names in a function call, as shown in the following
 example:
-
 \begin{codeblock}
 struct A { };
 void operator + (A, A);
@@ -1034,7 +1031,6 @@
 \tcode{T}
 a class type,
 the candidate functions are selected as follows:
-
 \begin{itemize}
 \item
 The \deflinkx{converting constructors}{constructor!converting}{class.conv.ctor} of
@@ -1080,7 +1076,6 @@
 Assuming that ``\cv{} \tcode{T}'' is the
 type of the object being initialized,
 the candidate functions are selected as follows:
-
 \begin{itemize}
 \item
 The permissible types for non-explicit conversion functions are
@@ -1152,7 +1147,6 @@
 is performed according to the rules in this subclause
 or when forming a list-initialization sequence according to \ref{over.ics.list},
 overload resolution selects the constructor in two phases:
-
 \begin{itemize}
 \item
 If the initializer list is not empty or \tcode{T} has no default constructor,
@@ -1233,7 +1227,6 @@
 For each \grammarterm{deduction-guide},
 a function or function template
 with the following properties:
-
 \begin{itemize}
 \item
 The \grammarterm{template-head}, if any,
@@ -2664,7 +2657,6 @@
 Two implicit conversion sequences of the same form are
 indistinguishable conversion sequences unless one of the
 following rules applies:
-
 \begin{itemize}
 \item
 List-initialization sequence \tcode{L1} is a better conversion sequence than
@@ -2873,7 +2865,6 @@
                                 // better than \tcode{short} $\to$ \tcode{float}.
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -2882,7 +2873,6 @@
 a Conversion.
 Two conversion sequences with the same rank are indistinguishable unless
 one of the following rules applies:
-
 \begin{itemize}
 \item
 A conversion that does not convert a pointer or a pointer to member
@@ -4038,7 +4028,6 @@
 \pnum
 The declaration of a literal operator shall have a
 \grammarterm{parameter-declaration-clause} equivalent to one of the following:
-
 \begin{codeblock}
 const char*
 unsigned long long int
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index af805491bd..51425ab529 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -143,7 +143,6 @@
 (optionally after whitespace containing no new-line characters) or
 follows whitespace containing at least one new-line character,
 and is
-
 \begin{itemize}
 \item
 a \tcode{\#} preprocessing token, or
@@ -558,7 +557,6 @@
 \begin{example}
 This demonstrates a way to include a library \tcode{optional} facility
 only if it is available:
-
 \begin{codeblock}
 #if __has_include(<optional>)
 #  include <optional>
@@ -717,14 +715,12 @@
 with the implementation and the \tcode{" "} form for sources
 outside the control of the implementation
 achieves wider portability. For instance:
-
 \begin{codeblock}
 #include <stdio.h>
 #include <unistd.h>
 #include "usefullib.h"
 #include "myprog.h"
 \end{codeblock}
-
 \end{note}
 
 \pnum
@@ -732,7 +728,6 @@
 This illustrates macro-replaced
 \tcode{\#include}
 directives:
-
 \begin{codeblock}
 #if VERSION == 1
     #define INCFILE  "vers1.h"
@@ -1458,7 +1453,6 @@
 \pnum
 \begin{example}
 In the following fragment:
-
 \begin{codeblock}
 #define hash_hash # ## #
 #define mkstr(a) # a
@@ -1468,7 +1462,6 @@
 \end{codeblock}
 
 The expansion produces, at various stages:
-
 \begin{codeblock}
 join(x, y)
 in_between(x hash_hash y)
@@ -1696,7 +1689,6 @@
 
 \pnum
 The following macro names shall be defined by the implementation:
-
 \begin{description}
 
 \item
@@ -1910,7 +1902,6 @@
 
 \pnum
 The following macro names are conditionally defined by the implementation:
-
 \begin{description}
 \item
 \indextext{__stdc__@\mname{STDC}}%
@@ -1945,7 +1936,6 @@
 \mname{STDCPP_THREADS}\\
 Defined, and has the value integer literal 1, if and only if a program
 can have more than one \link{thread of execution}{intro.multithread}.
-
 \end{description}
 
 \pnum
diff --git a/source/ranges.tex b/source/ranges.tex
index dd7a95e5d0..61ac3097c6 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -631,7 +631,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -692,7 +691,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -818,7 +816,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -882,7 +879,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -1007,7 +1003,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{T} is an array of unknown bound\iref{term.array.type},
@@ -1093,7 +1088,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{T} is an array of unknown bound\iref{term.array.type},
@@ -1144,7 +1138,6 @@
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -1629,7 +1622,6 @@
 \pnum
 Many of the types in subclause~\ref{range.utility} are specified in terms of
 the following exposition-only concepts:
-
 \begin{codeblock}
 template<class R>
   concept @\defexposconceptnc{simple-view}@ =                                     // \expos
@@ -5716,7 +5708,6 @@
 \tcode{views::take(E, F)} is ill-formed.
 Otherwise, the expression \tcode{views::take(E, F)}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{T} is a specialization
@@ -5737,7 +5728,6 @@
 ranges::be\-gin(E) + std::min<D>(ranges::distance(E), F))},
 except that \tcode{E} is evaluated only once,
 where \tcode{U} is a type determined as follows:
-
 \begin{itemize}
 \item if \tcode{T} is a specialization of \tcode{span},
 then \tcode{U} is \tcode{span<typename T::element_type>};
@@ -6181,7 +6171,6 @@
 \tcode{views::drop(E, F)} is ill-formed.
 Otherwise, the expression \tcode{views::drop(E, F)}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{T} is a specialization of
@@ -7244,7 +7233,6 @@
 \exposid{Base} and \exposid{InnerBase} each model \libconcept{forward_range}.
 In that case,
 \tcode{\exposid{iterator}::iterator_category} is defined as follows:
-
 \begin{itemize}
 \item
 Let \placeholder{OUTERC} denote
@@ -9506,7 +9494,6 @@
 \end{note}
 Otherwise, \tcode{views::counted(E, F)}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{T} models \libconcept{contiguous_iterator},
diff --git a/source/regex.tex b/source/regex.tex
index cbcdee3274..042cfdeae0 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3865,7 +3865,6 @@
 \tcode{graph}, \tcode{lower}, \tcode{print}, \tcode{punct}, \tcode{space},
 \tcode{upper}, \tcode{xdigit}, \tcode{d}, \tcode{s}, \tcode{w}.
 In addition the following expressions shall be equivalent:
-
 \begin{outputblock}
 \d @\textnormal{and}@ [[:digit:]]
 
@@ -3954,7 +3953,6 @@
 is \tcode{false} then the character \tcode{c} is matched if \tcode{c1
 <= c \&\& c <= c2}, otherwise \tcode{c} is matched in
 accordance with the following algorithm:
-
 \begin{codeblock}
 string_type str1 = string_type(1,
   flags() & icase ?
diff --git a/source/statements.tex b/source/statements.tex
index ad3c2822cf..6ebc0ef1ba 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -705,7 +705,6 @@
 
 \item
 \exposid{begin-expr} and \exposid{end-expr} are determined as follows:
-
 \begin{itemize}
 \item if the type of \exposid{range} is a reference to an
 array type \tcode{R}, \exposid{begin-expr} and \exposid{end-expr} are
@@ -836,7 +835,6 @@
 causes control to pass to the loop-continuation portion of the
 smallest such enclosing statement, that is, to the end
 of the loop. More precisely, in each of the statements
-
 \begin{minipage}{.30\hsize}
 \begin{codeblock}
 while (foo) {
@@ -867,7 +865,6 @@
 }
 \end{codeblock}
 \end{minipage}
-
 a \keyword{continue} not contained in an enclosed iteration statement is
 equivalent to \tcode{goto} \exposid{contin}.
 
diff --git a/source/support.tex b/source/support.tex
index 487de5716d..6922d28657 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -2367,7 +2367,6 @@
 
 \pnum
 \default
-
 \begin{itemize}
 \item
 Executes a loop:
@@ -2837,7 +2836,6 @@
 \pnum
 \begin{example}
 This can be useful for constructing an object at a known address:
-
 \begin{codeblock}
 void* place = operator new(sizeof(Something));
 Something* p = new (place) Something();
@@ -4298,7 +4296,6 @@
 Each is specified in terms of an exposition-only data member named \tcode{value}
 whose value typically corresponds to that of an enumerator
 from one of the following exposition-only enumerations:
-
 \begin{codeblock}
 enum class @\placeholdernc{ord}@ { @\placeholdernc{equal}@ = 0, @\placeholdernc{equivalent}@ = @\placeholdernc{equal}@, @\placeholdernc{less}@ = -1, @\placeholdernc{greater}@ = 1 }; // \expos
 enum class @\placeholdernc{ncmp}@ { @\placeholdernc{unordered}@ = -127 };                                     // \expos
@@ -5207,7 +5204,6 @@
 denotes a type\iref{temp.deduct},
 then \tcode{coroutine_traits<R, ArgTypes...>} has the following publicly
 accessible member:
-
 \begin{codeblock}
 using promise_type = typename R::promise_type;
 \end{codeblock}
diff --git a/source/templates.tex b/source/templates.tex
index 4576295060..9acd6a3233 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -219,7 +219,6 @@
 The syntax for
 \grammarterm{template-parameter}{s}
 is:
-
 \begin{bnf}
 \nontermdef{template-parameter}\br
   type-parameter\br
@@ -1436,7 +1435,6 @@
 Given an invented class template \tcode{X}
 with the \grammarterm{template-head} of \tcode{A} (including default arguments
 and \grammarterm{requires-clause}, if any):
-
 \begin{itemize}
 \item
 Each of the two function templates has the same template parameters
@@ -1727,7 +1725,6 @@
 can be constrained by the use of a \grammarterm{requires-clause}.
 This allows the specification of constraints for that declaration as
 an expression:
-
 \begin{bnf}
 \nontermdef{constraint-expression}\br
     logical-or-expression
@@ -1743,7 +1740,6 @@
 \pnum
 \indextext{constraint!associated|see{associated constraints}}%
 A declaration's \defn{associated constraints} are defined as follows:
-
 \begin{itemize}
 \item If there are no introduced \grammarterm{constraint-expression}{s},
 the declaration has no associated constraints.
@@ -2357,7 +2353,6 @@
 
 declares three member functions of a class template.
 The subscript function can be defined like this:
-
 \begin{codeblock}
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
@@ -2731,7 +2726,6 @@
 The form of the pattern
 depends on the context in which the expansion occurs. Pack
 expansions can occur in the following contexts:
-
 \begin{itemize}
 \item In a function parameter pack\iref{dcl.fct}; the pattern is the
 \grammarterm{parameter-declaration} without the ellipsis.
@@ -3309,7 +3303,6 @@
 \pnum
 Within the argument list of a partial specialization,
 the following restrictions apply:
-
 \begin{itemize}
 \item
 The type of a template parameter corresponding to a specialized non-type argument
@@ -3323,7 +3316,6 @@
 int array[5];
 template< int X > class A<X,&array> { };        // error
 \end{codeblock}
-
 \end{example}
 \item
 The partial specialization shall be more specialized than the primary
@@ -3449,7 +3441,6 @@
 rewrite to two function templates, the first function template is more
 specialized than the second according to the \link{ordering rules for function
 templates}{temp.func.order}:
-
 \begin{itemize}
 \item
 Each of the two
@@ -3601,7 +3592,6 @@
 A function template defines an unbounded set of related functions.
 \begin{example}
 A family of sort functions can be declared like this:
-
 \begin{codeblock}
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
@@ -3656,7 +3646,6 @@
 }
 \end{codeblock}
 \end{minipage}
-
 \end{example}
 
 \pnum
@@ -3838,7 +3827,6 @@
 as distinct.
 For example, the last two declarations are functionally
 equivalent and would cause a program to be ill-formed:
-
 \begin{codeblock}
 // guaranteed to be the same
 template <int I> void f(A<I>, A<I+10>);
@@ -3918,7 +3906,6 @@
 is reversed.
 For a function template $M$ with cv-qualifiers \cv{}
 that is a member of a class $A$:
-
 \begin{itemize}
 \item
 The type $X(M)$ is ``rvalue reference to \cv{}~$A$''
@@ -4163,7 +4150,6 @@
   void g(TT<int, Alloc<int>>);
 g(v);               // OK, \tcode{TT} = \tcode{vector}
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -5011,7 +4997,6 @@
 
 \pnum
 A qualified name\iref{basic.lookup.qual} is dependent if
-
 \begin{itemize}
 \item
 it is a \grammarterm{conversion-function-id}
@@ -5223,7 +5208,6 @@
 or
 \grammarterm{new-type-id}
 is dependent, even if any subexpression is type-dependent:
-
 \begin{ncsimplebnf}
 simple-type-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
 simple-type-specifier braced-init-list\br
@@ -5241,7 +5225,6 @@
 \pnum
 Expressions of the following forms are never type-dependent (because the type
 of the expression cannot be dependent):
-
 \begin{ncsimplebnf}
 literal\br
 \keyword{sizeof} unary-expression\br
@@ -5334,7 +5317,6 @@
 is type-dependent or the
 \grammarterm{type-id}
 is dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} unary-expression\br
 \keyword{sizeof} \terminal{(} type-id \terminal{)}\br
@@ -5359,7 +5341,6 @@
 or
 \grammarterm{cast-expression}
 is value-dependent:
-
 \begin{ncsimplebnf}
 simple-type-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
 \keyword{static_cast} \terminal{<} type-id \terminal{>} \terminal{(} expression \terminal{)}\br
@@ -5370,7 +5351,6 @@
 
 \pnum
 Expressions of the following form are value-dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} \terminal{...} \terminal{(} identifier \terminal{)}\br
 fold-expression
@@ -6254,7 +6234,6 @@
 
 \pnum
 The syntax for explicit instantiation is:
-
 \begin{bnf}
 \nontermdef{explicit-instantiation}\br
   \opt{\keyword{extern}} \keyword{template} declaration
@@ -6728,7 +6707,6 @@
 The definition of a static data member of a template
 for which default-initialization is desired
 can use functional cast notation\iref{expr.type.conv}:
-
 \begin{codeblock}
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
@@ -6987,7 +6965,6 @@
 use refers to a specialization of a function template even when a
 non-template function\iref{dcl.fct} is visible that would otherwise be used.
 For example:
-
 \begin{codeblock}
 template <class T> int f(T);    // \#1
 int f(int);                     // \#2
@@ -7557,7 +7534,6 @@
 If
 \tcode{P}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -7652,7 +7628,6 @@
 is transformed as described above).
 However, there are
 three cases that allow a difference:
-
 \begin{itemize}
 \item
 If the original
@@ -7825,7 +7800,6 @@
 If
 \tcode{A}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -7871,7 +7845,6 @@
 identical to
 \tcode{A}.
 However, certain attributes of \tcode{A} may be ignored:
-
 \begin{itemize}
 \item
 If the original \tcode{A} is a reference type,
@@ -7916,7 +7889,6 @@
 \pnum
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
-
 \begin{itemize}
 \item
 In the context of a function call, the types used are those function parameter types
@@ -7944,7 +7916,6 @@
 \pnum
 Before the partial ordering is done, certain transformations are performed
 on the types used for partial ordering:
-
 \begin{itemize}
 \item
 If
@@ -8150,7 +8121,6 @@
 \tcode{P}
 can be composed from a number of other
 types, templates, and non-type values:
-
 \begin{itemize}
 \item
 A function type includes the types of each of the function parameters,
@@ -8192,7 +8162,6 @@
 
 \pnum
 The non-deduced contexts are:
-
 \indextext{context!non-deduced}%
 \begin{itemize}
 \item
@@ -8277,7 +8246,6 @@
 \begin{example}
 Here is an example in which different parameter/argument pairs produce
 inconsistent template argument deductions:
-
 \begin{codeblock}
 template<class T> void f(T x, T y) { @\commentellip@ }
 struct A { @\commentellip@ };
@@ -8294,7 +8262,6 @@
 single function parameter/argument pair.
 This can lead to conflicts
 that cause type deduction to fail:
-
 \begin{codeblock}
 template <class T, class U> void f(T (*)(T, U, U));
 
@@ -8311,7 +8278,6 @@
 
 Here is an example where the exception specification of a function type
 is deduced:
-
 \begin{codeblock}
 template<bool E> void f1(void (*)() noexcept(E));
 template<bool> struct A { };
@@ -8330,7 +8296,6 @@
 
 Here is an example where a qualification conversion applies between the
 argument type on the function call and the deduced template argument type:
-
 \begin{codeblock}
 template<class T> void f(const T*) { }
 int* p;
@@ -8341,7 +8306,6 @@
 
 Here is an example where the template argument is used to instantiate
 a derived class type of the corresponding function parameter type:
-
 \begin{codeblock}
 template <class T> struct B { };
 template <class T> struct D : public B<T> {};
diff --git a/source/threads.tex b/source/threads.tex
index 41566dd90e..2ddc900a88 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -6268,7 +6268,6 @@
 
 \pnum
 The expression \tcode{m.lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6311,7 +6310,6 @@
 
 \pnum
 The expression \tcode{m.try_lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6357,7 +6355,6 @@
 
 \pnum
 The expression \tcode{m.unlock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6512,7 +6509,6 @@
 \pnum
 The expression \tcode{m.try_lock_for(rel_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6554,7 +6550,6 @@
 \pnum
 The expression \tcode{m.try_lock_until(abs_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6741,7 +6736,6 @@
 \pnum
 The expression \tcode{m.lock_shared()} is well-formed and has the
 following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6778,7 +6772,6 @@
 
 \pnum
 The expression \tcode{m.unlock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6803,7 +6796,6 @@
 
 \pnum
 The expression \tcode{m.try_lock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6906,7 +6898,6 @@
 \pnum
 The expression \tcode{m.try_lock_shared_for(rel_time)} is well-formed and
 has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6951,7 +6942,6 @@
 \pnum
 The expression \tcode{m.try_lock_shared_until(abs_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -9101,7 +9091,6 @@
 \begin{itemdescr}
 \pnum
 \effects
-
 \begin{itemize}
 \item
 \indextext{block (execution)}%
@@ -10513,7 +10502,6 @@
 
 \pnum
 \errors
-
 \begin{itemize}
 \item \tcode{future_already_retrieved} if \tcode{get_future} has already been called on
 a \tcode{promise} with the same shared state as \tcode{*this}.
@@ -10576,7 +10564,6 @@
 
 \pnum
 \errors
-
 \begin{itemize}
 \item \tcode{promise_already_satisfied} if its shared state
 already has a stored value or exception.
@@ -10916,7 +10903,6 @@
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -11260,7 +11246,6 @@
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -11295,7 +11280,6 @@
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -11351,7 +11335,6 @@
 of the second function depends on the \tcode{policy} argument as follows (if
 more than one of these conditions applies, the implementation may choose any of
 the corresponding policies):
-
 \begin{itemize}
 \item
 If \tcode{launch::async} is set in \tcode{policy}, calls
diff --git a/source/time.tex b/source/time.tex
index 1f95cfdff3..93a7bfffd6 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2074,7 +2074,6 @@
 \end{codeblock}
 where \tcode{\placeholder{units-suffix}}
 depends on the type \tcode{Period::type} as follows:
-
 \begin{itemize}
 \item
 If \tcode{Period::type} is \tcode{atto},
@@ -2952,7 +2951,6 @@
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2015-06-30 23:59:59.500 UTC
 2015-06-30 23:59:59.750 UTC
@@ -3158,7 +3156,6 @@
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2000-01-01 00:00:00 UTC == 2000-01-01 00:00:32 TAI
 \end{outputblock}
@@ -3321,7 +3318,6 @@
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2000-01-01 00:00:00 UTC == 2000-01-01 00:00:13 GPS
 \end{outputblock}
@@ -3390,7 +3386,6 @@
 \pnum
 The type denoted by \tcode{file_clock} provides
 precisely one of the following two sets of static member functions:
-
 \begin{codeblock}
 template<class Duration>
   static sys_time<@\seebelow@>
@@ -3399,9 +3394,7 @@
   static file_time<@\seebelow@>
     from_sys(const sys_time<Duration>&);
 \end{codeblock}
-
 or:
-
 \begin{codeblock}
 template<class Duration>
   static utc_time<@\seebelow@>
@@ -3870,7 +3863,6 @@
 \constraints
 At least one of the following clock time conversion expressions
 is well-formed:
-
 \begin{itemize}
 \item
 \begin{codeblock}
@@ -7916,7 +7908,6 @@
 \pnum
 \begin{note}
 The year, month, and day are accepted in any of the following 3 orders:
-
 \begin{codeblock}
 @\tcode{\placeholder{year}}@/@\tcode{\placeholder{month}}@/@\tcode{\placeholder{day}}@
 @\tcode{\placeholder{month}}@/@\tcode{\placeholder{day}}@/@\tcode{\placeholder{year}}@
@@ -7924,7 +7915,6 @@
 \end{codeblock}
 
 Anywhere a \tcode{\placeholder{day}} is needed, any of the following can also be specified:
-
 \begin{codeblock}
 last
 @\tcode{\placeholder{weekday}}@[@\tcode{\placeholder{i}}@]
@@ -7937,7 +7927,6 @@
 Partial-date types such as \tcode{year_month} and \tcode{month_day}
 can be created by not applying the second division operator
 for any of the three orders. For example:
-
 \begin{codeblock}
 year_month ym = 2015y/April;
 month_day md1 = April/4;
@@ -9126,7 +9115,6 @@
 Initializes the base class with a sequence of \tcode{char}
 equivalent to that produced by \tcode{os.str()}
 initialized as shown below:
-
 \begin{codeblock}
 ostringstream os;
 os << tp << " is in a gap between\n"
@@ -9156,7 +9144,6 @@
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 2016-03-13 02:30:00 is in a gap between
 2016-03-13 02:00:00 EST and
@@ -9201,7 +9188,6 @@
 Initializes the base class with a sequence of \tcode{char}
 equivalent to that produced by \tcode{os.str()}
 initialized as shown below:
-
 \begin{codeblock}
 ostringstream os;
 os << tp << " is ambiguous.  It could be\n"
@@ -9229,7 +9215,6 @@
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 2016-11-06 01:30:00 is ambiguous.  It could be
 2016-11-06 01:30:00 EDT == 2016-11-06 05:30:00 UTC or
@@ -9283,7 +9268,6 @@
 the UTC offset in effect
 for the associated \tcode{time_zone} and \tcode{time_point}.
 The relationship between \tcode{local_time} and \tcode{sys_time} is:
-
 \begin{codeblock}
 offset = local_time - sys_time
 \end{codeblock}
@@ -9588,7 +9572,6 @@
 for the \tcode{zoned_time} default constructor,
 and constructors taking \tcode{string_view}.
 A specialization for \tcode{const time_zone*} is provided by the implementation:
-
 \begin{codeblock}
 namespace std::chrono {
   template<> struct zoned_traits<const time_zone*> {
@@ -10164,7 +10147,6 @@
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 1972-07-01 00:00:00: 1s
 1973-01-01 00:00:00: 1s
@@ -10463,7 +10445,6 @@
 interpret the format specification
 as a \fmtgrammarterm{chrono-format-spec}
 according to the following syntax:
-
 \begin{ncbnf}
 \fmtnontermdef{chrono-format-spec}\br
     \opt{fill-and-align} \opt{width} \opt{precision} \opt{\terminal{L}} \opt{chrono-specs}
diff --git a/source/utilities.tex b/source/utilities.tex
index 4adbf392a6..dd727db29f 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -259,7 +259,6 @@
 \pnum
 \remarks
 The exception specification is equivalent to:
-
 \begin{codeblock}
 is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>
 \end{codeblock}
@@ -2188,7 +2187,6 @@
 \remarks
 The exception specification is equivalent to the logical \logop{and} of the
 following expressions:
-
 \begin{codeblock}
 is_nothrow_move_assignable_v<@$\mathtt{T}_i$@>
 \end{codeblock}
@@ -3136,7 +3134,6 @@
 \pnum
 \remarks
 The exception specification is equivalent to:
-
 \begin{codeblock}
 noexcept(x.swap(y))
 \end{codeblock}
@@ -10031,7 +10028,6 @@
 Replaces each bit at position \tcode{I} in
 \tcode{*this}
 with a value determined as follows:
-
 \begin{itemize}
 \item
 If \tcode{I < pos}, the new value is zero;
@@ -10056,7 +10052,6 @@
 Replaces each bit at position \tcode{I} in
 \tcode{*this}
 with a value determined as follows:
-
 \begin{itemize}
 \item
 If \tcode{pos >= N - I}, the new value is zero;
@@ -10765,7 +10760,6 @@
 If a \Cpp{} program wants to have a by-element addition of two vectors \tcode{a}
 and \tcode{b} containing \tcode{double} and put the result into \tcode{a},
 it can do:
-
 \begin{codeblock}
 transform(a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
 \end{codeblock}
@@ -14250,7 +14244,6 @@
 The header provides partial specializations of \tcode{function_ref}
 for each combination of the possible replacements of
 the placeholders \cv{} and \placeholder{noex} where:
-
 \begin{itemize}
 \item \cv{} is either const or empty, and
 \item \placeholder{noex} is either \tcode{true} or \tcode{false}.
@@ -15859,7 +15852,6 @@
 An escape sequence is one of \noncxxtcode{\{\{} or \noncxxtcode{\}\}}.
 It is replaced with \noncxxtcode{\{} or \noncxxtcode{\}}, respectively, in the output.
 The syntax of replacement fields is as follows:
-
 \begin{ncbnf}
 \fmtnontermdef{replacement-field}\br
     \noncxxterminal{\{} \opt{arg-id} \opt{format-specifier} \noncxxterminal{\}}
@@ -15989,7 +15981,6 @@
 are only supported for arithmetic types.
 \end{note}
 The syntax of format specifications is as follows:
-
 \begin{ncbnf}
 \fmtnontermdef{std-format-spec}\br
     \opt{fill-and-align} \opt{sign} \opt{\noncxxterminal{\#}} \opt{\noncxxterminal{0}} \opt{width} \opt{precision} \opt{\noncxxterminal{L}} \opt{type}
@@ -17225,7 +17216,6 @@
 is a shift sequence, or
 is a sequence of ill-formed code units,
 processing is in order as follows:
-
 \begin{itemize}
 \item
 If \placeholder{X} encodes a single character \placeholder{C}, then:
@@ -17324,7 +17314,6 @@
 The escaped string representation of a character \placeholder{C}
 is equivalent to the escaped string representation
 of a string of \placeholder{C}, except that:
-
 \begin{itemize}
 \item
 the result starts and ends with \unicode{0027}{apostrophe} (\tcode{'})