htmlgen.patch

From 03a6b34783a158d7a17bda6bd327e0d5ffdef975 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Mon, 23 Jan 2017 06:58:26 +0100
Subject: [PATCH 1/9] Reduce excessive indentation of comments. Helps layout on
 smaller (e.g. half-screen) window sizes.

---
 source/basic.tex       | 26 +++++++++++++-------------
 source/expressions.tex |  2 +-
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/source/basic.tex b/source/basic.tex
index 516161ea..a94d3538 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -342,7 +342,7 @@ Given
 #include <string>
 
 struct C {
-  std::string s;                // \tcode{std::string} is the standard library class\iref{string.classes}
+  std::string s;    // \tcode{std::string} is the standard library class\iref{string.classes}
 };
 
 int main() {
@@ -2654,23 +2654,23 @@ namespace AB {
 
 void h()
 {
-  AB::g();          // \tcode{g} is declared directly in \tcode{AB}, therefore \tcode{S} is $\{ \tcode{AB::g()} \}$ and \tcode{AB::g()} is chosen
+  AB::g();      // \tcode{g} is declared directly in \tcode{AB}, therefore \tcode{S} is $\{ \tcode{AB::g()} \}$ and \tcode{AB::g()} is chosen
 
-  AB::f(1);         // \tcode{f} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B};
-                    // namespace \tcode{Y} is not searched and \tcode{Y::f(float)} is not considered;
-                    // \tcode{S} is $\{ \tcode{A::f(int)}, \tcode{B::f(char)} \}$ and overload resolution chooses \tcode{A::f(int)}
+  AB::f(1);     // \tcode{f} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B};
+                // namespace \tcode{Y} is not searched and \tcode{Y::f(float)} is not considered;
+                // \tcode{S} is $\{ \tcode{A::f(int)}, \tcode{B::f(char)} \}$ and overload resolution chooses \tcode{A::f(int)}
 
-  AB::f('c');       // as above but resolution chooses \tcode{B::f(char)}
+  AB::f('c');   // as above but resolution chooses \tcode{B::f(char)}
 
-  AB::x++;          // \tcode{x} is not declared directly in \tcode{AB}, and is not declared in \tcode{A} or \tcode{B}, so the rules
-                    // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \}$ so the program is ill-formed
+  AB::x++;      // \tcode{x} is not declared directly in \tcode{AB}, and is not declared in \tcode{A} or \tcode{B}, so the rules
+                // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \}$ so the program is ill-formed
 
-  AB::i++;          // \tcode{i} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B},
-                    // \tcode{S} is $\{ \tcode{A::i}, \tcode{B::i} \}$ so the use is ambiguous and the program is ill-formed
+  AB::i++;      // \tcode{i} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B},
+                // \tcode{S} is $\{ \tcode{A::i}, \tcode{B::i} \}$ so the use is ambiguous and the program is ill-formed
 
-  AB::h(16.8);      // \tcode{h} is not declared directly in \tcode{AB} and not declared directly in \tcode{A} or \tcode{B} so the rules
-                    // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \tcode{Y::h(int)}, \tcode{Z::h(double)} \}$ and
-                    // overload resolution chooses \tcode{Z::h(double)}
+  AB::h(16.8);  // \tcode{h} is not declared directly in \tcode{AB} and not declared directly in \tcode{A} or \tcode{B} so the rules
+                // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \tcode{Y::h(int)}, \tcode{Z::h(double)} \}$ and
+                // overload resolution chooses \tcode{Z::h(double)}
 }
 \end{codeblock}
 \end{example}
diff --git a/source/expressions.tex b/source/expressions.tex
index fb3c8c03..6029d91a 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -2989,7 +2989,7 @@ struct s2 {
   }
   auto g() {
     return [] {
-      return [*this] { };       // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}
+      return [*this] { };   // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}
     }();
   }
 };
-- 
2.43.0


From 432bdba579a9a1a6a711cfb86b84eb3f0a848093 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 1 Feb 2017 03:24:29 +0100
Subject: [PATCH 2/9] Use new link macros.

---
 source/algorithms.tex    |   4 +-
 source/basic.tex         |  93 +++++++-------
 source/classes.tex       |  22 ++--
 source/compatibility.tex |   4 +-
 source/concepts.tex      |  12 +-
 source/containers.tex    |  48 ++++----
 source/declarations.tex  |  55 ++++-----
 source/diagnostics.tex   |   6 +-
 source/exceptions.tex    |  34 +++---
 source/expressions.tex   | 258 ++++++++++++++++++++-------------------
 source/future.tex        |  10 +-
 source/intro.tex         |  19 +--
 source/iostreams.tex     |  74 +++++------
 source/iterators.tex     |   6 +-
 source/lex.tex           |   6 +-
 source/lib-intro.tex     |  67 +++++-----
 source/limits.tex        |   2 +-
 source/numerics.tex      |  53 ++++----
 source/overloading.tex   |  64 +++++-----
 source/preprocessor.tex  |  12 +-
 source/statements.tex    |  30 ++---
 source/strings.tex       |   8 +-
 source/support.tex       |  86 ++++++-------
 source/templates.tex     | 114 ++++++++---------
 source/threads.tex       |  35 +++---
 source/time.tex          |  10 +-
 source/utilities.tex     |  20 +--
 27 files changed, 570 insertions(+), 582 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index 95b1a818..450e1200 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -5,7 +5,7 @@
 
 \pnum
 This Clause describes components that \Cpp{} programs may use to perform
-algorithmic operations on containers\iref{containers} and other sequences.
+algorithmic operations on \link{containers}{containers} and other sequences.
 
 \pnum
 The following subclauses describe components for
@@ -10224,7 +10224,7 @@ In either case, twice as many projections as comparisons.
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \begin{itemdecl}
diff --git a/source/basic.tex b/source/basic.tex
index a94d3538..19a1b025 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -180,7 +180,7 @@ or the \tcode{*\keyword{this}} object\iref{expr.prim.this}.
 \indextext{linkage}%
 A name used in more than one translation unit can potentially
 refer to the same entity in these translation units depending on the
-linkage\iref{basic.link} of the name specified in each
+\link{linkage}{basic.link} of the name specified in each
 translation unit.
 
 \rSec1[basic.def]{Declarations and definitions}
@@ -205,7 +205,7 @@ A declaration can also have effects including:
 \item a static assertion\iref{dcl.pre},
 \item controlling template instantiation\iref{temp.explicit},
 \item guiding template argument deduction for constructors\iref{temp.deduct.guide},
-\item use of attributes\iref{dcl.attr}, and
+\item use of \link{attributes}{dcl.attr}, and
 \item nothing (in the case of an \grammarterm{empty-declaration}).
 \end{itemize}
 \end{note}
@@ -334,7 +334,7 @@ In some circumstances, \Cpp{} implementations implicitly define the
 default constructor\iref{class.default.ctor},
 copy constructor, move constructor\iref{class.copy.ctor},
 copy assignment operator, move assignment operator\iref{class.copy.assign},
-or destructor\iref{class.dtor} member functions.
+or \link{destructor}{class.dtor} member functions.
 \end{note}
 \begin{example}
 Given
@@ -419,7 +419,7 @@ defined as follows:
 an \grammarterm{id-expression}\iref{expr.prim.id} or
 a \grammarterm{splice-expression}\iref{expr.prim.splice}, the set
 contains only $E$.
-\item If $E$ is a subscripting operation\iref{expr.sub} with
+\item If $E$ is a \link{subscripting}{expr.sub} operation with
 an array operand, the set contains the potential results of that operand.
 \item If $E$ is a class member access
 expression\iref{expr.ref} of the form
@@ -430,16 +430,15 @@ the set contains the potential results of $E_1$.
 \item If $E$ is a class member access expression
 naming a static data member,
 the set contains the \grammarterm{id-expression} designating the data member.
-\item If $E$ is a pointer-to-member
-expression\iref{expr.mptr.oper} of the form
+\item If $E$ is a \link{pointer-to-member expression}{expr.mptr.oper} of the form
 $E_1$ \tcode{.*} $E_2$,
 the set contains the potential results of $E_1$.
 \item If $E$ has the form \tcode{($E_1$)}, the set contains the
 potential results of $E_1$.
-\item If $E$ is a glvalue conditional
-expression\iref{expr.cond}, the set is the union of the sets of
+\item If $E$ is a glvalue \link{conditional expression}{expr.cond},
+the set is the union of the sets of
 potential results of the second and third operands.
-\item If $E$ is a comma expression\iref{expr.comma}, the set
+\item If $E$ is a \link{comma expression}{expr.comma}, the set
 contains the potential results of the right operand.
 \item Otherwise, the set is empty.
 \end{itemize}
@@ -601,8 +600,8 @@ implicitly-defined
 copy assignment or move assignment function for another class as specified
 in~\ref{class.copy.assign}.
 A constructor for a class is odr-used as specified
-in~\ref{dcl.init}. A destructor for a class is odr-used if it is potentially
-invoked\iref{class.dtor}.
+in~\ref{dcl.init}. A destructor for a class is odr-used if it is
+\deflink{potentially invoked}{class.dtor}.
 
 \pnum
 A local entity\iref{basic.pre}
@@ -674,7 +673,7 @@ void h() {
 \pnum
 Every program shall contain at least one definition of every
 function or variable that is odr-used in that program
-outside of a discarded statement\iref{stmt.if}; no diagnostic required\ifndrdef{basic.def.odr.minimum.one.def}.
+outside of a \deflink{discarded statement}{stmt.if}; no diagnostic required\ifndrdef{basic.def.odr.minimum.one.def}.
 The definition can appear explicitly in the program, it can be found in
 the standard or a user-defined library, or (when appropriate) it is
 implicitly defined (see~\ref{class.default.ctor}, \ref{class.copy.ctor},
@@ -722,9 +721,9 @@ The rules for declarations and expressions
 describe in which contexts complete class types are required. A class
 type \tcode{T} must be complete if
 \begin{itemize}
-\item an object of type \tcode{T} is defined\iref{basic.def}, or
-\item a non-static class data member of type \tcode{T} is
-declared\iref{class.mem}, or
+\item an object of type \tcode{T} is \link{defined}{basic.def}, or
+\item a non-static class \deflink{data member}{class.mem} of
+type \tcode{T} is declared, or
 \item \tcode{T} is used as the allocated type or array element type in a
 \grammarterm{new-expression}\iref{expr.new}, or
 \item an lvalue-to-rvalue conversion is applied to
@@ -744,7 +743,7 @@ a \keyword{static_cast}\iref{expr.static.cast}, or
 \keyword{sizeof} operator\iref{expr.sizeof} is applied to an operand of
 type \tcode{T}, or
 \item a function with a return type or argument type of type \tcode{T}
-is defined\iref{basic.def} or called\iref{expr.call}, or
+is defined\iref{basic.def} or \link{called}{expr.call}, or
 \item a class with a base class of type \tcode{T} is
 defined\iref{class.derived}, or
 \item an lvalue of type \tcode{T} is assigned to\iref{expr.assign}, or
@@ -2947,7 +2946,7 @@ are attached to the same module.
 \indextext{linkage!\idxcode{inline} and}%
 \indextext{\idxcode{inline}!linkage of}%
 The name of an entity
-that belongs to a namespace scope\iref{basic.scope.namespace}
+that belongs to a \link{namespace scope}{basic.scope.namespace}
 has internal linkage if it is the name of
 \begin{itemize}
 \item
@@ -2988,7 +2987,7 @@ typedef declaration in which the class has the typedef name for linkage
 purposes\iref{dcl.typedef}; or
 \item
 \indextext{enumeration!linkage of}%
-a named enumeration\iref{dcl.enum}, or an unnamed enumeration defined
+a named \link{enumeration}{dcl.enum}, or an unnamed enumeration defined
 in a typedef declaration in which the enumeration has the typedef name
 for linkage purposes\iref{dcl.typedef}; or
 \item an unnamed enumeration
@@ -3064,7 +3063,7 @@ the declaration at line \#3 still redeclares \#1 and receives internal linkage.
 \pnum
 \indextext{linkage!no}%
 Names not covered by these rules have no linkage. Moreover, except as
-noted, a name declared at block scope\iref{basic.scope.block} has no
+noted, a name declared at \deflinkx{block scope}{scope!block}{basic.scope.block} has no
 linkage.
 
 \pnum
@@ -3424,8 +3423,8 @@ features of the language, such as references and virtual functions, might
 involve additional memory locations that are not accessible to programs but are
 managed by the implementation.
 \end{note}
-Two or more threads of
-execution\iref{intro.multithread} can access separate memory
+Two or more \deflinkx{threads of
+execution}{thread of execution}{intro.multithread} can access separate memory
 locations without interfering with each other.
 
 \pnum
@@ -3469,15 +3468,15 @@ bit-fields \tcode{b} and \tcode{c} cannot be concurrently modified, but
 The constructs in a \Cpp{} program create, destroy, refer to, access, and
 manipulate objects.
 An \defn{object} is created
-by a definition\iref{basic.def},
+by a \link{definition}{basic.def},
 by a \grammarterm{new-expression}\iref{expr.new},
 by an operation that implicitly creates objects (see below),
-when implicitly changing the active member of a union\iref{class.union},
+when implicitly changing the active member of a \link{union}{class.union},
 or
 when a temporary object is created\iref{conv.rval,class.temporary}.
 An object occupies a region of storage
 in its period of construction\iref{class.cdtor},
-throughout its lifetime\iref{basic.life},
+throughout its \link{lifetime}{basic.life},
 and
 in its period of destruction\iref{class.cdtor}.
 \begin{note}
@@ -3611,7 +3610,7 @@ A \defn{potentially-overlapping subobject} is either:
 \begin{itemize}
 \item a base class subobject, or
 \item a non-static data member
-declared with the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}.
+declared with the \link{\tcode{no_unique_address}}{dcl.attr.nouniqueaddr} attribute.
 \end{itemize}
 
 \pnum
@@ -3632,7 +3631,7 @@ Otherwise, the circumstances under which the object has zero size
 are \impldef{which non-standard-layout objects
 containing no data are considered empty}.
 \indextext{most derived object!bit-field}%
-Unless it is a bit-field\iref{class.bit},
+Unless it is a \link{bit-field}{class.bit},
 an object with nonzero size
 shall occupy one or more bytes of storage,
 including every byte that is occupied in full or in part
@@ -4274,16 +4273,16 @@ the result of the evaluation is that erroneous value:
   is produced by the evaluation of:
   \begin{itemize}
   \item
-    the second or third operand of a conditional expression\iref{expr.cond},
+    the second or third operand of a \link{conditional expression}{expr.cond},
   \item
-    the right operand of a comma expression\iref{expr.comma},
+    the right operand of a \link{comma expression}{expr.comma},
   \item
     the operand of a cast or conversion\iref{conv.integral,
     expr.type.conv,expr.static.cast,expr.cast}
     to an unsigned ordinary character type
     or \tcode{std::byte} type\iref{cstddef.syn}, or
   \item
-    a discarded-value expression\iref{expr.context},
+    a \deflink{discarded-value expression}{expr.context},
   \end{itemize}
   then the result of the operation is an indeterminate value or
   that erroneous value, respectively.
@@ -4474,8 +4473,8 @@ specified in~\ref{class.copy.elision}.
 \indextext{storage duration!dynamic|(}
 
 \pnum
-Objects can be created dynamically during program
-execution\iref{intro.execution}, using
+Objects can be created dynamically during \link{program
+execution}{intro.execution}, using
 \indextext{\idxcode{new}}%
 \grammarterm{new-expression}{s}\iref{expr.new}, and destroyed using
 \indextext{\idxcode{delete}}%
@@ -4639,9 +4638,9 @@ that would match a handler\iref{except.handle} of type
 \tcode{std::bad_alloc}\iref{bad.alloc}.
 
 \pnum
-A global allocation function is only called as the result of a new
-expression\iref{expr.new}, or called directly using the function call
-syntax\iref{expr.call}, or called indirectly to allocate storage for
+A global allocation function is only called as the result of a \link{new
+expression}{expr.new}, or called directly using the \link{function call}{expr.call}
+syntax, or called indirectly to allocate storage for
 a coroutine state\iref{dcl.fct.def.coroutine},
 or called indirectly through calls to the
 functions in the \Cpp{} standard library.
@@ -5167,9 +5166,9 @@ shall be destroyed before
 impose requirements on implementations regarding the representation
 of types.
 There are two kinds of types: fundamental types and compound types.
-Types describe objects\iref{intro.object},
-references\iref{dcl.ref},
-or functions\iref{dcl.fct}.
+Types describe \link{objects}{intro.object},
+\link{references}{dcl.ref},
+or \link{functions}{dcl.fct}.
 \end{note}
 
 \pnum
@@ -5288,7 +5287,7 @@ Arithmetic types\iref{basic.fundamental}, enumeration types,
 pointer types, pointer-to-member types\iref{basic.compound},
 \tcode{std::meta::\brk{}info}, \tcode{std::nullptr_t},
 and
-cv-qualified\iref{basic.type.qualifier} versions of these
+\link{cv-qualified}{basic.type.qualifier} versions of these
 types are collectively called
 \defnadjx{scalar}{types}{type}.
 \label{term.trivially.copyable.type}%
@@ -5313,7 +5312,7 @@ A type is a \defnadj{literal}{type} if it is:
 \item a scalar type; or
 \item a reference type; or
 \item an array of literal type; or
-\item a possibly cv-qualified class type\iref{class} that
+\item a possibly cv-qualified \link{class type}{class} that
 has all of the following properties:
 \begin{itemize}
 \item it has a constexpr destructor\iref{dcl.constexpr},
@@ -5347,8 +5346,8 @@ will be usable in a constant expression.
 Two types \cvqual{cv1} \tcode{T1} and \cvqual{cv2} \tcode{T2} are
 \defnadjx{layout-compatible}{types}{type}
 if \tcode{T1} and \tcode{T2} are the same type,
-layout-compatible enumerations\iref{dcl.enum}, or
-layout-compatible standard-layout class types\iref{class.mem}.
+\deflinkx{layout-compatible enumerations}{layout-compatible!enumeration}{dcl.enum}, or
+\deflinkx{layout-compatible standard-layout class types}{layout-compatible!class}{class.mem}.
 
 \rSec2[basic.types.trivial]{Trivially copyable types}
 
@@ -5973,7 +5972,7 @@ ordinary pointers to objects or functions.
 which identify members of a given
 type within objects of a given class, \ref{dcl.mptr}.
 Pointers to data members and pointers to member functions are collectively
-called \term{pointer-to-member} types.
+called \defn{pointer-to-member} types.
 \end{itemize}
 
 \pnum
@@ -6051,7 +6050,7 @@ layout-compatible types shall
 have the same value representation and alignment
 requirements\iref{basic.align}.
 \begin{note}
-Pointers to over-aligned types\iref{basic.align} have no special
+Pointers to \deflinkx{over-aligned types}{type!over-aligned}{basic.align} have no special
 representation, but their range of valid values is restricted by the extended
 alignment requirement.
 \end{note}
@@ -6400,8 +6399,8 @@ the definition of the usual arithmetic conversions\iref{expr.arith.conv}.
 \indextext{program execution|(}
 
 \pnum
-An instance of each object with automatic storage
-duration\iref{basic.stc.auto} is associated with each entry into its
+An instance of each object with \link{automatic storage
+duration}{basic.stc.auto} is associated with each entry into its
 block. Such an object exists and retains its last-stored value during
 the execution of the block and while the block is suspended (by a call
 of a function, suspension of a coroutine\iref{expr.await}, or receipt of a signal).
@@ -6446,7 +6445,7 @@ if $E$ is a \grammarterm{lambda-expression}\iref{expr.prim.lambda},
 the initialization of the entities captured by copy and
 the constituent expressions of the \grammarterm{initializer} of the \grammarterm{init-capture}{s},
 \item
-if $E$ is a function call\iref{expr.call} or implicitly invokes a function,
+if $E$ is a \link{function call}{expr.call} or implicitly invokes a function,
 the constituent expressions of each default argument\iref{dcl.fct.default}
 used in the call, and
 \item
@@ -6477,7 +6476,7 @@ are not subexpressions of a nested unevaluated operand\iref{term.unevaluated.ope
 A \defn{full-expression} is
 \begin{itemize}
 \item
-an unevaluated operand\iref{expr.context},
+an \deflink{unevaluated operand}{expr.context},
 \item
 a \grammarterm{constant-expression}\iref{expr.const.core},
 \item
diff --git a/source/classes.tex b/source/classes.tex
index 2349cbc8..f1fc3a66 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -188,10 +188,10 @@ A class \tcode{S} is a \defnadj{standard-layout}{class} if it:
 \item has no non-static data members of type non-standard-layout class
 (or array of such types) or reference,
 
-\item has no virtual functions\iref{class.virtual} and no
-virtual base classes\iref{class.mi},
+\item has no \link{virtual functions}{class.virtual} and no
+\link{virtual base classes}{class.mi},
 
-\item has the same access control\iref{class.access}
+\item has the same \link{access control}{class.access}
 for all non-static data members,
 
 \item has no non-standard-layout base classes,
@@ -574,7 +574,7 @@ if it is
 \end{itemize}
 For any other \grammarterm{member-declaration},
 each declared entity
-that is not an unnamed bit-field\iref{class.bit}
+that is not an \deflinkx{unnamed bit-field}{bit-field!unnamed}{class.bit}
 is a member of the class,
 and each such \grammarterm{member-declaration}
 shall either
@@ -593,7 +593,7 @@ Nested types are classes\iref{class.name,class.nest} and
 enumerations\iref{dcl.enum} declared in the class and arbitrary types
 declared as members by use of a typedef declaration\iref{dcl.typedef}
 or \grammarterm{alias-declaration}.
-The enumerators of an unscoped enumeration\iref{dcl.enum} defined in the class
+The enumerators of an \link{unscoped enumeration}{dcl.enum} defined in the class
 are members of the class.
 
 \pnum
@@ -739,9 +739,9 @@ shall contain a \grammarterm{type-specifier} that is not a \grammarterm{cv-quali
 The
 \grammarterm{member-declarator-list} can be omitted only after a
 \grammarterm{class-specifier} or an \grammarterm{enum-specifier} or in a
-friend declaration\iref{class.friend}. A
+\link{friend declaration}{class.friend}. A
 \grammarterm{pure-specifier} shall be used only in the declaration of a
-virtual function\iref{class.virtual}
+\link{virtual function}{class.virtual}
 that is not a friend declaration.
 
 \pnum
@@ -844,7 +844,7 @@ unscoped enumeration type; and
 
 \pnum
 In addition, if class \tcode{T} has a user-declared
-constructor\iref{class.ctor}, every non-static data member of class
+\link{constructor}{class.ctor}, every non-static data member of class
 \tcode{T} shall have a name different from \tcode{T}.
 
 \pnum
@@ -894,7 +894,7 @@ non-static data members (in any order) have layout-compatible
 types\iref{term.layout.compatible.type}.
 
 \pnum
-In a standard-layout union with an active member\iref{class.union}
+In a standard-layout union with an \deflinkx{active member}{active!union member}{class.union}
 of struct type \tcode{T1}, it is permitted to read a non-static
 data member \tcode{m} of another union member of struct type \tcode{T2}
 provided \tcode{m} is part of the common initial sequence of \tcode{T1} and \tcode{T2};
@@ -2236,7 +2236,7 @@ by a \grammarterm{new-expression}\iref{expr.new}; the context of the invocation
 An array of class type contains several subobjects for each of which
 the destructor is invoked.
 \end{note}
-A destructor can also be invoked explicitly. A destructor is \term{potentially invoked}
+A destructor can also be invoked explicitly. A destructor is \defn{potentially invoked}
 if it is invoked or as specified in~\ref{expr.new},
 \ref{stmt.return}, \ref{dcl.init.aggr},
 \ref{class.base.init}, and~\ref{except.throw}.
@@ -6353,7 +6353,7 @@ associated with a \grammarterm{try-block} (if there is one),
 the copy-initialization of the exception object can be omitted by
 constructing $o$ directly into the exception object;
 
-\item in a coroutine\iref{dcl.fct.def.coroutine}, a copy of a coroutine parameter
+\item in a \link{coroutine}{dcl.fct.def.coroutine}, a copy of a coroutine parameter
 can be omitted and references to that copy replaced with references to the
 corresponding parameter if the meaning of the program will be unchanged except for
 the execution of a constructor and destructor for the parameter copy object;
diff --git a/source/compatibility.tex b/source/compatibility.tex
index f5910a9d..03244784 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -2092,8 +2092,8 @@ deallocation functions\iref{expr.new}.
 A conditional expression with a throw expression as its second or third
 operand keeps the type and value category of the other operand.
 \rationale
-Formerly mandated conversions (lvalue-to-rvalue\iref{conv.lval},
-array-to-pointer\iref{conv.array}, and function-to-pointer\iref{conv.func}
+Formerly mandated conversions (\link{lvalue-to-rvalue}{conv.lval},
+\link{array-to-pointer}{conv.array}, and \link{function-to-pointer}{conv.func}
 standard conversions), especially the creation of the temporary due to
 lvalue-to-rvalue conversion, were considered gratuitous and surprising.
 \effect
diff --git a/source/concepts.tex b/source/concepts.tex
index d1e15a6e..42828a4b 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -300,7 +300,7 @@ classifications, and fundamental type properties.
 
 \begin{itemdecl}
 template<class T, class U>
-  concept @\defexposconcept{same-as-impl}@ = is_same_v<T, U>;       // \expos
+  concept @\defexposconcept{same-as-impl}@ = @\libglobalref{is_same_v}@<T, U>;       // \expos
 
 template<class T, class U>
   concept @\deflibconcept{same_as}@ = @\exposconcept{same-as-impl}@<T, U> && @\exposconcept{same-as-impl}@<U, T>;
@@ -493,13 +493,13 @@ Users can customize the behavior of \libconcept{common_with} by specializing the
 
 \begin{itemdecl}
 template<class T>
-  concept @\deflibconcept{integral}@ = is_integral_v<T>;
+  concept @\deflibconcept{integral}@ = @\libglobalref{is_integral_v}@<T>;
 template<class T>
-  concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && is_signed_v<T>;
+  concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && @\libglobalref{is_signed_v}@<T>;
 template<class T>
   concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;
 template<class T>
-  concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;
+  concept @\deflibconcept{floating_point}@ = @\libglobalref{is_floating_point_v}@<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -748,7 +748,7 @@ types.
 
 \begin{itemdecl}
 template<class T>
-  concept @\deflibconcept{destructible}@ = is_nothrow_destructible_v<T>;
+  concept @\deflibconcept{destructible}@ = @\libglobalref{is_nothrow_destructible_v}@<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -768,7 +768,7 @@ variable of a given type with a particular set of argument types.
 
 \begin{itemdecl}
 template<class T, class... Args>
-  concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && is_constructible_v<T, Args...>;
+  concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && @\libglobalref{is_constructible_v}@<T, Args...>;
 \end{itemdecl}
 
 \rSec2[concept.default.init]{Concept \cname{default_initializable}}
diff --git a/source/containers.tex b/source/containers.tex
index 5e4ba772..2d6290b2 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -6144,14 +6144,14 @@ namespace std {
 \indextext{\idxcode{array}!contiguous storage}%
 The header \libheader{array} defines a class template for storing fixed-size
 sequences of objects.
-An \tcode{array} is a contiguous container\iref{container.reqmts}.
+An \tcode{array} is a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.
 An instance of \tcode{array<T, N>} stores \tcode{N} elements of type \tcode{T},
 so that \tcode{size() == N} is an invariant.
 
 \pnum
 \indextext{\idxcode{array}!initialization}%
 \indextext{\idxcode{array}!as aggregate}%
-An \tcode{array} is an aggregate\iref{dcl.init.aggr} that can be
+An \tcode{array} is an \deflink{aggregate}{dcl.init.aggr} that can be
 list-initialized with up
 to \tcode{N} elements whose types are convertible to \tcode{T}.
 
@@ -6162,8 +6162,8 @@ of a container\iref{container.reqmts} and
 of a reversible container\iref{container.rev.reqmts},
 except that a default
 constructed \tcode{array} object is not empty if $\tcode{N} > 0$.
-An \tcode{array} meets some of the requirements of a sequence
-container\iref{sequence.reqmts}.
+An \tcode{array} meets some of the requirements of a
+\link{sequence container}{sequence.reqmts}.
 Descriptions are provided here
 only for operations on \tcode{array} that are not described in
 one of these tables and
@@ -6173,7 +6173,7 @@ for operations where there is additional semantic information.
 \tcode{array<T, N>} is a structural type\iref{term.structural.type} if
 \tcode{T} is a structural type.
 Two values \tcode{a1} and \tcode{a2} of type \tcode{array<T, N>}
-are template-argument-equivalent\iref{temp.type} if and only if
+are \deflink{template-argument-equivalent}{temp.type} if and only if
 each pair of corresponding elements in \tcode{a1} and \tcode{a2}
 are template-argument-equivalent.
 
@@ -6498,7 +6498,7 @@ namespace std {
 A
 \indexlibraryglobal{deque}%
 \tcode{deque}
-is a sequence container that supports random access iterators\iref{random.access.iterators}.
+is a sequence container that supports \link{random access iterators}{random.access.iterators}.
 In addition, it supports constant time insert and erase operations at the beginning or the end;
 insert and erase in the middle take linear time.
 That is, a deque is especially optimized for pushing and popping elements at the beginning and end.
@@ -7163,7 +7163,7 @@ namespace std {
 \pnum
 An incomplete type \tcode{T} may be used when instantiating \tcode{forward_list}
 if the allocator meets the
-allocator completeness requirements\iref{allocator.requirements.completeness}.
+\link{allocator completeness requirements}{allocator.requirements.completeness}.
 \tcode{T} shall be complete before any member of the resulting specialization
 of \tcode{forward_list} is referenced.
 
@@ -7747,7 +7747,7 @@ predicate.
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{unique}{forward_list}%
@@ -7852,7 +7852,7 @@ Approximately $N \log N$ comparisons, where $N$ is \tcode{distance(begin(), end(
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{reverse}{forward_list}%
@@ -9087,7 +9087,7 @@ A
 is a sequence container that supports
 bidirectional iterators and allows constant time insert and erase
 operations anywhere within the sequence, with storage management handled
-automatically. Unlike vectors\iref{vector} and deques\iref{deque},
+automatically. Unlike \link{vectors}{vector} and \link{deques}{deque},
 fast random access to list elements is not supported, but many
 algorithms only need sequential access anyway.
 
@@ -9263,7 +9263,7 @@ namespace std {
 \pnum
 An incomplete type \tcode{T} may be used when instantiating \tcode{list}
 if the allocator meets the
-allocator completeness requirements\iref{allocator.requirements.completeness}.
+\link{allocator completeness requirements}{allocator.requirements.completeness}.
 \tcode{T} shall be complete before any member of the resulting specialization
 of \tcode{list} is referenced.
 
@@ -9676,7 +9676,7 @@ applications of the corresponding predicate.
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{unique}{list}%
@@ -9799,7 +9799,7 @@ comparisons, where $N$ is \tcode{size()}.
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \rSec3[list.erasure]{Erasure}
@@ -9907,7 +9907,7 @@ of an allocator-aware container\iref{container.alloc.reqmts},
 of a sequence container, including most of the optional sequence container
 requirements\iref{sequence.reqmts},
 and, for an element type other than \tcode{bool},
-of a contiguous container\iref{container.reqmts}.
+of a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.
 The exceptions are the
 \tcode{push_front}, \tcode{prepend_range}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not
 provided. Descriptions are provided here only for operations on \tcode{vector}
@@ -10045,7 +10045,7 @@ namespace std {
 \pnum
 An incomplete type \tcode{T} may be used when instantiating \tcode{vector}
 if the allocator meets the
-allocator completeness requirements\iref{allocator.requirements.completeness}.
+\link{allocator completeness requirements}{allocator.requirements.completeness}.
 \tcode{T} shall be complete before any member of the resulting specialization
 of \tcode{vector} is referenced.
 
@@ -10638,7 +10638,7 @@ Unless described below, all operations have the same requirements and
 semantics as the \tcode{vector} primary template, except that operations
 dealing with the \tcode{bool} value type map to bit values in the
 container storage and
-\tcode{allocator_traits::construct}\iref{allocator.traits.members}
+\libmemberrefx{allocator_traits::construct}{allocator_traits}{construct}
 is not used to construct these values.
 
 \pnum
@@ -15844,9 +15844,9 @@ and
 can be used to instantiate
 \tcode{queue}.
 In particular,
-\tcode{list}\iref{list}
+\link{\tcode{list}}{list}
 and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
 can be used.
 
 \begin{codeblock}
@@ -16201,15 +16201,15 @@ and
 can be used to instantiate
 \tcode{priority_queue}.
 In particular,
-\tcode{vector}\iref{vector}
+\link{\tcode{vector}}{vector}
 and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
 can be used.
 Instantiating
 \tcode{priority_queue}
 also involves supplying a function or function object for making
 priority comparisons; the library assumes that the function or function
-object defines a strict weak ordering\iref{alg.sorting}.
+object defines a \link{strict weak ordering}{alg.sorting}.
 
 \begin{codeblock}
 namespace std {
@@ -16757,10 +16757,10 @@ and
 can be used to instantiate
 \tcode{stack}.
 In particular,
-\tcode{vector}\iref{vector},
-\tcode{list}\iref{list}
+\link{\tcode{vector}}{vector},
+\link{\tcode{list}}{list}
 and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
 can be used.
 
 \rSec3[stack.defn]{Definition}
diff --git a/source/declarations.tex b/source/declarations.tex
index d3821deb..7dd1bc59 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -547,7 +547,7 @@ in explicit specializations and explicit instantiations, respectively.
 \begin{note}
 A variable declared without a \grammarterm{storage-class-specifier}
 at block scope or declared as a function parameter
-has automatic storage duration by default\iref{basic.stc.auto}.
+has \deflinkx{automatic storage duration}{storage duration!automatic}{basic.stc.auto} by default.
 \end{note}
 
 \pnum
@@ -815,10 +815,10 @@ an alias template or a type template template parameter.
 A \grammarterm{simple-template-id} that names a class template specialization
 is a \grammarterm{class-name}\iref{class.name}.
 If a \grammarterm{typedef-name} is used to identify the subject of an
-\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a class
-definition\iref{class}, a constructor
-declaration\iref{class.ctor}, or a destructor
-declaration\iref{class.dtor}, the program is ill-formed.
+\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a \link{class
+definition}{class}, a \link{constructor
+declaration}{class.ctor}, or a \link{destructor
+declaration}{class.dtor}, the program is ill-formed.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -1151,7 +1151,7 @@ If an inline function or variable that is attached to a named module
 is declared in a definition domain,
 it shall be defined in that domain.
 \begin{note}
-A constexpr function\iref{dcl.constexpr} is implicitly inline.
+A \deflinkx{constexpr function}{specifier!\idxcode{constexpr}!function}{dcl.constexpr} is implicitly inline.
 In the global module, a function defined within a class definition
 is implicitly inline\iref{class.mfct,class.friend}.
 \end{note}
@@ -1290,7 +1290,7 @@ the object referenced is a non-const object and can be modified through
 some other access path.
 \begin{note}
 Cv-qualifiers are supported by the type system so that they cannot be
-subverted without casting\iref{expr.const.cast}.
+subverted without \link{casting}{expr.const.cast}.
 \end{note}
 
 \pnum
@@ -1740,8 +1740,7 @@ is \tcode{T\&}, where \tcode{T} is the type of $E$;
 \item otherwise, \tcode{decltype($E$)} is the type of $E$.
 \end{itemize}
 
-The operand of the \keyword{decltype} specifier is an unevaluated
-operand\iref{term.unevaluated.operand}.
+The operand of the \keyword{decltype} specifier is an \deflink{unevaluated operand}{expr.context}.
 
 \begin{example}
 \begin{codeblock}
@@ -1940,7 +1939,7 @@ explicitly allowed in \ref{dcl.spec.auto} is ill-formed.
 If the \grammarterm{init-declarator-list} contains more than one
 \grammarterm{init-declarator}, they shall all form declarations of
 variables. The type of each declared variable is determined
-by placeholder type deduction\iref{dcl.type.auto.deduct},
+by \deflink{placeholder type deduction}{dcl.type.auto.deduct},
 and if the type that replaces the placeholder type is not the
 same in each deduction, the program is ill-formed.
 
@@ -2082,7 +2081,7 @@ A function declared with a return type that uses a placeholder type shall not
 be a coroutine\iref{dcl.fct.def.coroutine}.
 
 \pnum
-An explicit instantiation declaration\iref{temp.explicit} does not cause the
+An \link{explicit instantiation declaration}{temp.explicit} does not cause the
 instantiation of an entity declared using a placeholder type, but it also does
 not prevent that entity from being instantiated as needed to determine its
 type.
@@ -2297,7 +2296,7 @@ in the \grammarterm{type-specifier-seq}
 in the \grammarterm{new-type-id} or \grammarterm{nofun-type-id}
 of a \grammarterm{new-expression}\iref{expr.new},
 as the \grammarterm{simple-type-specifier}
-in an explicit type conversion (functional notation)\iref{expr.type.conv},
+in an \link{explicit type conversion (functional notation)}{expr.type.conv},
 or
 as the \grammarterm{type-specifier} in the \grammarterm{parameter-declaration}
 of a \grammarterm{template-parameter}\iref{temp.param}.
@@ -4556,7 +4555,7 @@ int a;
 int f(int a, int b = a);            // error: parameter \tcode{a} used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter \tcode{I} found
-int h(int a, int b = sizeof(a));    // OK, unevaluated operand\iref{term.unevaluated.operand}
+int h(int a, int b = sizeof(a));    // OK, \deflink{unevaluated operand}{expr.context}
 \end{codeblock}
 \end{example}
 A non-static member shall not be designated in a default argument unless
@@ -6379,15 +6378,15 @@ This requires a conversion
 function\iref{class.conv.fct} returning a reference type.
 \end{footnote}
 (this conversion is selected by enumerating the applicable conversion
-functions\iref{over.match.ref} and choosing the best one through overload
-resolution\iref{over.match}),
+functions\iref{over.match.ref} and choosing the best one through \link{overload
+resolution}{over.match}),
 \end{itemize}
 then the reference binds to the initializer expression lvalue in the
 first case and to the lvalue result of the conversion
 in the second case (or, in either case, to the appropriate base class subobject of the object).
 \begin{note}
-The usual lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard
+The usual \link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard
 conversions are not needed, and therefore are suppressed, when such
 direct bindings to lvalues are done.
 \end{note}
@@ -7927,7 +7926,7 @@ the initializer is
 where \tcode{get} undergoes argument-dependent lookup\iref{basic.lookup.argdep}.
 In either case, \tcode{get<i>} is interpreted as a \grammarterm{template-id}.
 \begin{note}
-Ordinary unqualified lookup\iref{basic.lookup.unqual} is not performed.
+Ordinary \link{unqualified lookup}{basic.lookup.unqual} is not performed.
 \end{note}
 In either case, \exposid{e} is an lvalue if the type of the entity \exposid{e}
 is an lvalue reference and an xvalue otherwise.
@@ -8078,7 +8077,7 @@ is not looked up and is introduced by
 the \grammarterm{enum-specifier} or \grammarterm{opaque-enum-declaration}.
 If the \grammarterm{enum-head-name} of an \grammarterm{opaque-enum-declaration} contains
 a \grammarterm{nested-name-specifier},
-the declaration shall be an explicit specialization\iref{temp.expl.spec}.
+the declaration shall be an \link{explicit specialization}{temp.expl.spec}.
 
 \pnum
 \indextext{constant!enumeration}%
@@ -8244,7 +8243,7 @@ and the same values.
 
 \pnum
 The value of an enumerator or an object of an unscoped enumeration type is
-converted to an integer by integral promotion\iref{conv.prom}.
+converted to an integer by \deflinkx{integral promotion}{integral promotion}{conv.prom}.
 \begin{example}
 \begin{codeblock}
 enum color { red, yellow, green=20, blue };
@@ -8527,7 +8526,7 @@ appertains to the namespace being defined or extended.
 Members of an inline namespace can be used in most respects as though they were members
 of the innermost enclosing namespace. Specifically, the inline namespace and its enclosing
 namespace are both added to the set of associated namespaces used in
-argument-dependent lookup\iref{basic.lookup.argdep} whenever one of them is,
+\link{argument-dependent lookup}{basic.lookup.argdep} whenever one of them is,
 and a \grammarterm{using-directive}\iref{namespace.udir} that names the inline
 namespace is implicitly inserted into the enclosing namespace as for an unnamed
 namespace\iref{namespace.unnamed}. Furthermore, each
@@ -9360,7 +9359,7 @@ different language linkages are distinct types even if they are
 otherwise identical.
 
 \pnum
-Linkage\iref{basic.link} between \Cpp{} and  non-\Cpp{} code fragments can
+\link{Linkage}{basic.link} between \Cpp{} and  non-\Cpp{} code fragments can
 be achieved using a \grammarterm{linkage-specification}:
 
 \indextext{\idxgram{linkage-specification}}%
@@ -9690,18 +9689,18 @@ For each individual attribute, the form of the
 \pnum
 In an \grammarterm{attribute-list}, an ellipsis may appear only if that
 \grammarterm{attribute}'s specification permits it. An \grammarterm{attribute} followed
-by an ellipsis is a pack expansion\iref{temp.variadic}.
+by an ellipsis is a \deflink{pack expansion}{temp.variadic}.
 An \grammarterm{attribute-specifier} that contains
 an \grammarterm{attribute-list} with no \grammarterm{attribute}s
 has no effect.
 The order in which the \grammarterm{attribute-token}{s} appear in an
 \grammarterm{attribute-list} is not significant. If a
-keyword\iref{lex.key}
-or an alternative token\iref{lex.digraph} that satisfies the syntactic requirements
+\link{keyword}{lex.key}
+or an \link{alternative token}{lex.digraph} that satisfies the syntactic requirements
 of an \grammarterm{identifier}\iref{lex.name} is
 contained in
-an \grammarterm{attribute-token}, it is considered an identifier. No name
-lookup\iref{basic.lookup} is performed on any of the identifiers contained in an
+an \grammarterm{attribute-token}, it is considered an identifier. No
+\link{name lookup}{basic.lookup} is performed on any of the identifiers contained in an
 \grammarterm{attribute-token}. The \grammarterm{attribute-token} determines additional
 requirements on the \grammarterm{attribute-argument-clause} (if any).
 
@@ -9999,7 +9998,7 @@ unless the implementation can issue such diagnostic messages.
 
 \pnum
 The \grammarterm{attribute-token} \tcode{fallthrough}
-may be applied to a null statement\iref{stmt.expr};
+may be applied to a \deflinkx{null statement}{statement!null}{stmt.expr};
 such a statement is a \defnadj{fallthrough}{statement}.
 No \grammarterm{attribute-argument-clause} shall be present.
 A fallthrough statement may only appear within
diff --git a/source/diagnostics.tex b/source/diagnostics.tex
index cd913a8e..89419def 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -508,13 +508,13 @@ the current state of \tcode{NDEBUG} each time that
 
 \pnum
 An expression \tcode{assert(E)}
-is a constant subexpression\iref{defns.const.subexpr}, if
+is a \link{constant subexpression}{defns.const.subexpr}, if
 \begin{itemize}
 \item
 \tcode{NDEBUG} is defined at the point where \tcode{assert}
 is last defined or redefined, or
 \item
-\tcode{E} contextually converted to \tcode{bool}\iref{conv}
+\tcode{E} \deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv}
 is a constant subexpression that evaluates to the value \tcode{true}.
 \end{itemize}
 
@@ -1624,7 +1624,7 @@ application program interfaces.
 \pnum
 \begin{note}
 If an error represents an out-of-memory condition, implementations are
-encouraged to throw an exception object of type \tcode{bad_alloc}\iref{bad.alloc} rather
+encouraged to throw an exception object of type \link{\tcode{bad_alloc}}{bad.alloc} rather
 than \tcode{system_error}.
 \end{note}
 \indexlibraryglobal{system_error}%
diff --git a/source/exceptions.tex b/source/exceptions.tex
index 23e143e1..be584f9d 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -184,7 +184,7 @@ try : i(f(ii)), d(id) {
 
 \pnum
 In this Clause, ``before'' and ``after'' refer to the
-``sequenced before'' relation\iref{intro.execution}.
+\deflinkx{``sequenced before''}{sequenced before}{intro.execution} relation.
 
 \rSec1[except.throw]{Throwing an exception}%
 \indextext{exception handling!throwing}%
@@ -285,7 +285,7 @@ immediately after the destruction of the object (if any)
 declared in the \grammarterm{exception-declaration} in the handler;
 
 \item
-when an object of type \tcode{std::exception_ptr}\iref{propagation}
+when an object of type \libglobalrefx{std::exception_ptr}{exception_ptr}
 that refers to the exception object is destroyed,
 before the destructor of \tcode{std::exception_ptr} returns.
 \end{itemize}
@@ -293,7 +293,7 @@ before the destructor of \tcode{std::exception_ptr} returns.
 Among all points of potential destruction for the exception object,
 there is an unspecified last one
 where the exception object is destroyed.
-All other points happen before that last one\iref{intro.races}.
+All other points \deflinkx{happen before}{happens before}{intro.races} that last one.
 \begin{note}
 No other thread synchronization is implied in exception handling.
 \end{note}
@@ -341,7 +341,7 @@ returns the number of uncaught exceptions in the current thread.
 \indextext{exception handling!rethrow}%
 \indextext{rethrow|see{exception handling, rethrow}}%
 An exception is considered caught when a handler for that exception
-becomes active\iref{except.handle}.
+becomes \deflinkx{active}{exception handling!handler!active}{except.handle}.
 \begin{note}
 An exception can have active handlers and still be considered uncaught if
 it is rethrown.
@@ -353,7 +353,7 @@ it is rethrown.
 If the exception handling mechanism
 handling an uncaught exception
 directly invokes a function that exits via an
-exception, the function \tcode{std::terminate} is invoked\iref{except.terminate}.
+exception, the function \link{\tcode{std::terminate}}{except.terminate} is invoked.
 \begin{example}
 \begin{codeblock}
 struct C {
@@ -490,7 +490,7 @@ Such destruction is sequenced before entering a handler of the
 \pnum
 \begin{note}
 If the object was allocated by a \grammarterm{new-expression}\iref{expr.new},
-the matching deallocation function\iref{basic.stc.dynamic.deallocation},
+the matching \link{deallocation function}{basic.stc.dynamic.deallocation},
 if any, is called to free the storage occupied by the object.
 \end{note}
 
@@ -555,12 +555,12 @@ that can be converted to \tcode{T} by one or more of
 \begin{itemize}
 
 \item%
-a standard pointer conversion\iref{conv.ptr} not involving conversions
+a standard \link{pointer conversion}{conv.ptr} not involving conversions
 to pointers to private or protected or ambiguous classes,
 \item%
-a function pointer conversion\iref{conv.fctptr},
+a \link{function pointer conversion}{conv.fctptr},
 \item%
-a qualification conversion\iref{conv.qual}, or
+a \link{qualification conversion}{conv.qual}, or
 
 \end{itemize}
 
@@ -697,7 +697,7 @@ Exceptions thrown in destructors of objects with static storage duration or in
 constructors of objects associated with non-block variables with static storage duration are not caught by a
 \grammarterm{function-try-block}
 on
-the \tcode{main} function\iref{basic.start.main}.
+the \link{\tcode{main} function}{basic.start.main}.
 Exceptions thrown in destructors of objects with thread storage duration or in constructors of objects associated with non-block variables with thread storage duration are not caught by a
 \grammarterm{function-try-block}
 on the initial function of the thread.
@@ -769,7 +769,7 @@ otherwise it has a
 The exception specification is either defined implicitly,
 or defined explicitly
 by using a \grammarterm{noexcept-specifier}
-as a suffix of a function declarator\iref{dcl.fct}.
+as a suffix of a \link{function declarator}{dcl.fct}.
 
 \begin{bnf}
 \nontermdef{noexcept-specifier}\br
@@ -811,7 +811,7 @@ in which cases the exception specification
 is as specified below
 and no other declaration for that function
 shall have a \grammarterm{noexcept-specifier}.
-In an explicit instantiation\iref{temp.explicit}
+In an \link{explicit instantiation}{temp.explicit}
 a \grammarterm{noexcept-specifier} may be specified,
 but is not required.
 If a \grammarterm{noexcept-specifier} is specified
@@ -860,7 +860,7 @@ An expression $E$ is
 \defnx{potentially-throwing}{potentially-throwing!expression} if
 \begin{itemize}
 \item
-$E$ is a function call\iref{expr.call}
+$E$ is a \link{function call}{expr.call}
 whose \grammarterm{postfix-expression}
 has a function type,
 or a pointer-to-function type,
@@ -941,7 +941,7 @@ the invocation of any assignment operator
 in the implicit definition is potentially-throwing.
 
 \pnum
-A deallocation function\iref{basic.stc.dynamic.deallocation}
+A \link{deallocation function}{basic.stc.dynamic.deallocation}
 with no explicit \grammarterm{noexcept-specifier}
 has a non-throwing exception specification.
 
@@ -1059,9 +1059,9 @@ via an exception, or
 \item%
 when the exception handling mechanism cannot find a handler for a thrown exception\iref{except.handle}, or
 
-\item when the search for a handler\iref{except.handle}
+\item when the search for a \link{handler}{except.handle}
 exits the function body of a function
-with a non-throwing exception specification\iref{except.spec},
+with a non-throwing \link{exception specification}{except.spec},
 including when a contract-violation handler
 invoked from an evaluation of
 a function contract assertion\iref{basic.contract.eval} associated with the function
@@ -1069,7 +1069,7 @@ exits via an exception,
 or
 
 \item%
-when the destruction of an object during stack unwinding\iref{except.ctor}
+when the destruction of an object during \deflink{stack unwinding}{except.ctor}
 terminates by throwing an exception, or
 
 \item%
diff --git a/source/expressions.tex b/source/expressions.tex
index 6029d91a..343e8173 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -33,14 +33,14 @@ effects.
 \indextext{operator!overloaded}%
 \begin{note}
 Operators can be overloaded, that is, given meaning when applied to
-expressions of class type\iref{class} or enumeration
-type\iref{dcl.enum}. Uses of overloaded operators are transformed into
+expressions of \link{class}{class} type or
+\link{enumeration}{dcl.enum} type. Uses of overloaded operators are transformed into
 function calls as described in~\ref{over.oper}. Overloaded operators
 obey the rules for syntax and evaluation order specified in \ref{expr.compound},
 but the requirements of operand type and value category are replaced
 by the rules for function call. Relations between operators, such as
-\tcode{++a} meaning \tcode{a += 1}, are not guaranteed for overloaded
-operators\iref{over.oper}.
+\tcode{++a} meaning \tcode{a += 1}, are not guaranteed for \link{overloaded
+operators}{over.oper}.
 \end{note}
 
 \pnum
@@ -259,7 +259,7 @@ xvalues; rvalue references to functions are treated as lvalues whether named or
 \begin{example}
 \begin{codeblock}
 struct A {
-  int m;
+int m;
 };
 A&& operator+(A, A);
 A&& f();
@@ -315,7 +315,7 @@ Unless otherwise specified\iref{expr.reinterpret.cast, expr.const.cast},
 whenever a prvalue
 that is not the result of the lvalue-to-rvalue conversion\iref{conv.lval}
 appears as an operand of an operator,
-the temporary materialization conversion\iref{conv.rval} is
+the \link{temporary materialization conversion}{conv.rval} is
 applied to convert the expression to an xvalue.
 
 \pnum
@@ -498,31 +498,31 @@ An unevaluated operand is not evaluated.
 In an unevaluated operand, a non-static class member can be
 named\iref{expr.prim.id} and naming of objects or functions does not, by
 itself, require that a definition be provided\iref{basic.def.odr}.
-An unevaluated operand is considered a full-expression\iref{intro.execution}.
+An unevaluated operand is considered a \deflink{full-expression}{intro.execution}.
 \end{note}
 
 \pnum
 In some contexts, an expression only appears for its side effects. Such an
 expression is called a \defn{discarded-value expression}.
-The array-to-pointer\iref{conv.array}
-and function-to-pointer\iref{conv.func} standard conversions are not
-applied. The lvalue-to-rvalue conversion\iref{conv.lval} is applied
+The \link{array-to-pointer}{conv.array}
+and \link{function-to-pointer}{conv.func} standard conversions are not
+applied. The \link{lvalue-to-rvalue}{conv.lval} conversion is applied
 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,
+\grammarterm{expression} is one of these expressions,
 \item \grammarterm{id-expression}\iref{expr.prim.id},
 \item \grammarterm{splice-expression}\iref{expr.prim.splice},
-\item subscripting\iref{expr.sub},
-\item class member access\iref{expr.ref},
-\item indirection\iref{expr.unary.op},
-\item pointer-to-member operation\iref{expr.mptr.oper},
-\item conditional expression\iref{expr.cond} where both the second and the
+\item \link{subscripting}{expr.sub},
+\item \link{class member access}{expr.ref},
+\item \deflink{indirection}{expr.unary.op},
+\item \link{pointer-to-member operation}{expr.mptr.oper},
+\item \link{conditional expression}{expr.cond} where both the second and the
       third operands are one of these expressions, or
-\item comma expression\iref{expr.comma} where the right operand is one of
+\item \link{comma expression}{expr.comma} where the right operand is one of
       these expressions.
 \end{itemize}
 
@@ -661,7 +661,7 @@ descriptions of those operators and contexts.
 \pnum
 \indextext{conversion!lvalue-to-rvalue}%
 \indextext{type!incomplete}%
-A glvalue\iref{basic.lval} of a non-function, non-array type \tcode{T}
+A \deflink{glvalue}{basic.lval} of a non-function, non-array type \tcode{T}
 can be converted to
 a prvalue.
 \begin{footnote}
@@ -686,18 +686,18 @@ is applied to an expression $E$, and either
 \begin{itemize}
 \item $E$ is not potentially evaluated, or
 \item the evaluation of $E$ results in the evaluation of a member
-      $E_\tcode{x}$ of the set of potential results of $E$, and $E_\tcode{x}$
-      names a variable \tcode{x} that is not odr-used by
-      $E_\tcode{x}$\iref{basic.def.odr},
+  $E_\tcode{x}$ of the set of potential results of $E$, and $E_\tcode{x}$
+  names a variable \tcode{x} that is not odr-used by
+  $E_\tcode{x}$\iref{basic.def.odr},
 \end{itemize}
 the value contained in the referenced object is not accessed.
 \begin{example}
 \begin{codeblock}
 struct S { int n; };
 auto f() {
-  S x { 1 };
-  constexpr S y { 2 };
-  return [&](bool b) { return (b ? y : x).n; };
+S x { 1 };
+constexpr S y { 2 };
+return [&](bool b) { return (b ? y : x).n; };
 }
 auto g = f();
 int m = g(false);   // undefined behavior: access of \tcode{x.n} outside its lifetime
@@ -874,11 +874,11 @@ allowed), a program could inadvertently modify a const object
 (as it is done on line \#2). For example,
 \begin{codeblock}
 int main() {
-  const char c = 'c';
-  char* pc;
-  const char** pcc = &pc;       // \#1: not allowed
-  *pcc = &c;
-  *pc = 'C';                    // \#2: modifies a const object
+const char c = 'c';
+char* pc;
+const char** pcc = &pc;       // \#1: not allowed
+*pcc = &c;
+*pc = 'C';                    // \#2: modifies a const object
 }
 \end{codeblock}
 \end{note}
@@ -1138,7 +1138,7 @@ the derived class object.
 \indextext{conversion!pointer-to-member}%
 \indextext{null member pointer conversion|see{conversion, null member pointer}}%
 \indextext{constant!null pointer}%
-A null pointer constant\iref{conv.ptr} can be converted to a
+A \deflinkx{null pointer constant}{constant!null pointer}{conv.ptr} can be converted to a
 pointer-to-member
 type; the result is the \defnx{null member pointer value}{value!null member pointer}
 of that type and is distinguishable from any pointer to member not
@@ -1368,7 +1368,7 @@ occur until the complete declarator is known.
 \begin{note}
 In a \grammarterm{trailing-return-type},
 the class being defined is not required to be complete
-for purposes of class member access\iref{expr.ref}.
+for purposes of \link{class member access}{expr.ref}.
 Class members declared later are not visible.
 \begin{example}
 \begin{codeblock}
@@ -1435,8 +1435,8 @@ meaning, except as otherwise indicated.
 An \grammarterm{id-expression} is a restricted form of a
 \grammarterm{primary-expression}.
 \begin{note}
-An \grammarterm{id-expression} can appear after \tcode{.} and \tcode{->}
-operators\iref{expr.ref}.
+An \grammarterm{id-expression} can appear after
+\link{\tcode{.} and \tcode{->} operators}{expr.ref}.
 \end{note}
 
 \pnum
@@ -1569,7 +1569,7 @@ In each case, the constraints of \tcode{f} are not satisfied.
 In the declaration of \tcode{p2},
 those constraints need to be satisfied
 even though
-\tcode{f} is an unevaluated operand\iref{term.unevaluated.operand}.
+\tcode{f} is an \deflink{unevaluated operand}{expr.context}.
 \end{example}
 \end{note}
 
@@ -2191,8 +2191,8 @@ void abssort(float* x, unsigned N) {
 A \grammarterm{lambda-expression} is a prvalue
 whose result object is called the \defn{closure object}.
 \begin{note}
-A closure object behaves like a function
-object\iref{function.objects}.
+A closure object behaves like a \link{function
+object}{function.objects}.
 \end{note}
 
 \pnum
@@ -2526,7 +2526,7 @@ The closure type for a non-generic \grammarterm{lambda-expression} with no
 and no explicit object parameter\iref{dcl.fct}
 whose constraints (if any) are satisfied
 has a conversion function to pointer to
-function with \Cpp{} language linkage\iref{dcl.link} having
+function with \Cpp{} language \link{linkage}{dcl.link} having
 the same parameter and return types as the closure type's function call operator.
 The conversion is to ``pointer to \keyword{noexcept} function''
 if the function call operator
@@ -2635,8 +2635,8 @@ GL_int(3);                      // OK, same as \tcode{GL(3)}
 
 \pnum
 The conversion function or conversion function template is public,
-constexpr, non-virtual, non-explicit, const, and has a non-throwing exception
-specification\iref{except.spec}.
+constexpr, non-virtual, non-explicit, const, and has a non-throwing \link{exception
+specification}{except.spec}.
 \begin{example}
 \begin{codeblock}
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
@@ -2694,9 +2694,9 @@ implicitly-declared destructor\iref{class.dtor}.
 
 \pnum
 A member of a closure type shall not be
-explicitly instantiated\iref{temp.explicit},
-explicitly specialized\iref{temp.expl.spec}, or
-named in a friend declaration\iref{class.friend}.
+\link{explicitly instantiated}{temp.explicit},
+\link{explicitly specialized}{temp.expl.spec}, or
+named in a \link{friend declaration}{class.friend}.
 
 \rSec3[expr.prim.lambda.capture]{Captures}%
 
@@ -3285,7 +3285,7 @@ A fold expression is a pack expansion.
 \pnum
 A \grammarterm{requires-expression} provides a concise way to express
 requirements on template arguments
-that can be checked by name lookup\iref{basic.lookup}
+that can be checked by \link{name lookup}{basic.lookup}
 or by checking properties of types and expressions.
 
 \begin{bnf}
@@ -3890,7 +3890,7 @@ or a prvalue of function pointer type.
 If the selected
 function is non-virtual, or if the \grammarterm{id-expression} in the class
 member access expression is a \grammarterm{qualified-id}, that function is
-called. Otherwise, its final overrider\iref{class.virtual} in the dynamic type
+called. Otherwise, its \deflink{final overrider}{class.virtual} in the dynamic type
 of the object expression is called; such a call is referred to as a
 \defnx{virtual function call}{function!virtual function call}.
 \begin{note}
@@ -3903,8 +3903,8 @@ an object under construction or destruction.
 
 \pnum
 \begin{note}
-If a function name is used, and name
-lookup\iref{basic.lookup} does not find a declaration of that name,
+If a function name is used, and \link{name
+lookup}{basic.lookup} does not find a declaration of that name,
 the program is ill-formed. No function is implicitly declared by such a
 call.
 \end{note}
@@ -4025,7 +4025,7 @@ function,
 the object expression of the class member access shall be a glvalue and
 the implicit object parameter of the function\iref{over.match.funcs}
 is initialized with that glvalue,
-converted as if by an explicit type conversion\iref{expr.cast}.
+converted as if by an \link{explicit type conversion}{expr.cast}.
 \begin{note}
 There is no access or ambiguity checking on this conversion; the access
 checking and disambiguation are done as part of the (possibly implicit)
@@ -4162,10 +4162,10 @@ pointer parameters.
 \pnum
 \indextext{declaration!ellipsis in function}%
 \indextext{parameter list!variable}%
-A function can be declared to accept fewer arguments (by declaring default
-arguments\iref{dcl.fct.default}) or more arguments (by using the ellipsis,
+A function can be declared to accept fewer arguments (by declaring \link{default
+arguments}{dcl.fct.default}) or more arguments (by using the ellipsis,
 \tcode{...}, or a function parameter pack\iref{dcl.fct}) than the number of
-parameters in the function definition\iref{dcl.fct.def}.
+parameters in the \link{function definition}{dcl.fct.def}.
 \begin{note}
 This implies that, except where the ellipsis (\tcode{...}) or a function
 parameter pack is used, a parameter is available for each argument.
@@ -4183,8 +4183,8 @@ thus each such argument has a corresponding parameter when a function template
 specialization is actually called.
 \end{note}
 The
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the argument expression.
 An argument that has type \cv{}~\tcode{std::nullptr_t} is converted
 to type \tcode{\keyword{void}*}\iref{conv.ptr}.
@@ -4199,16 +4199,16 @@ an eligible non-trivial move constructor, or
 a non-trivial destructor\iref{class.dtor},
 with no corresponding parameter, is conditionally-supported with
 \impldef{passing argument of class type through ellipsis} semantics. If the argument has
-integral or enumeration type that is subject to the integral
-promotions\iref{conv.prom}, or a floating-point type that is subject to the
-floating-point promotion\iref{conv.fpprom}, the value of the argument is converted to the
+integral or enumeration type that is subject to the \link{integral
+promotions}{conv.prom}, or a floating-point type that is subject to the
+\link{floating-point promotion}{conv.fpprom}, the value of the argument is converted to the
 promoted type before the call. These promotions are referred to as
 the \defnx{default argument promotions}{promotion!default argument promotion}.
 
 \pnum
 \indextext{function call!recursive}%
-Recursive calls are permitted, except to the \tcode{main}
-function\iref{basic.start.main}.
+Recursive calls are permitted, except to the \link{\tcode{main}
+function}{basic.start.main}.
 
 \pnum
 A function call is an lvalue
@@ -4227,8 +4227,8 @@ except as specified in \ref{dcl.type.decltype}.
 \indextext{type conversion, explicit|see{casting}}%
 \indextext{conversion explicit type|see{casting}}%
 \indextext{casting}%
-A \grammarterm{simple-type-specifier}\iref{dcl.type.simple} or
-\grammarterm{typename-specifier}\iref{temp.res} followed
+A \link{\grammarterm{simple-type-specifier}}{dcl.type.simple} or
+\link{\grammarterm{typename-specifier}}{temp.res} followed
 by a parenthesized optional \grammarterm{expression-list} or
 by a \grammarterm{braced-init-list}
 (the initializer)
@@ -4239,7 +4239,7 @@ If the type is a placeholder
 for a deduced class type,
 it is replaced by the return type
 of the function selected by overload resolution
-for class template deduction\iref{over.match.class.deduct}
+for \link{class template deduction}{over.match.class.deduct}
 for the remainder of this subclause.
 Otherwise, if the type contains a placeholder type,
 it is replaced by the type
@@ -4638,8 +4638,8 @@ void foo(D* dp) {
 \end{example}
 
 \pnum
-Otherwise, \tcode{v} shall be a pointer to or a glvalue of a polymorphic
-type\iref{class.virtual}.
+Otherwise, \tcode{v} shall be a pointer to or a glvalue of a
+\deflinkx{polymorphic type}{class!polymorphic}{class.virtual}.
 
 \pnum
 If \tcode{v} is a null pointer value, the result is a null pointer value.
@@ -4690,9 +4690,9 @@ runtime check \term{fails}.
 
 \pnum
 The value of a failed cast to pointer type is the null pointer value of
-the required result type. A failed cast to reference type throws
-an exception\iref{except.throw} of a type that would match a
-handler\iref{except.handle} of type \tcode{std::bad_cast}\iref{bad.cast}.
+the required result type. A failed cast to reference type \link{throws
+an exception}{except.throw} of a type that would match a
+\link{handler}{except.handle} of type \link{\tcode{std::bad_cast}}{bad.cast}.
 
 \indextext{\idxcode{bad_cast}}%
 \indexlibraryglobal{bad_cast}%
@@ -4781,13 +4781,13 @@ glvalue refers.
 When \keyword{typeid} is applied to an expression other than a glvalue of
 a polymorphic class type, the result refers to a \tcode{std::type_info}
 object representing the static type of the expression.
-Lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} conversions are not applied to
+\link{Lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} conversions are not applied to
 the expression.
 If the expression is a prvalue,
-the temporary materialization conversion\iref{conv.rval}
+the \link{temporary materialization conversion}{conv.rval}
 is applied.
-The expression is an unevaluated operand\iref{term.unevaluated.operand}.
+The expression is an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 When \keyword{typeid} is applied to a \grammarterm{type-id}, the result
@@ -4881,7 +4881,7 @@ of type \tcode{T1} can be cast to type ``rvalue
 reference to \tcode{T2}'' if \tcode{T2} is reference-compatible with
 \tcode{T1}\iref{dcl.init.ref}. If the value is not a bit-field,
 the result refers to the object or the specified base class subobject
-thereof; otherwise, the lvalue-to-rvalue conversion\iref{conv.lval}
+thereof; otherwise, the \link{lvalue-to-rvalue conversion}{conv.lval}
 is applied to the bit-field and the resulting prvalue is used as the
 operand of the \keyword{static_cast} for the remainder of this subclause.
 If \tcode{T2} is an inaccessible\iref{class.access} or
@@ -4986,7 +4986,8 @@ Otherwise, the behavior is undefined\ubdef{expr.static.cast.fp.outside.range}.
 A prvalue of type ``pointer to \cvqual{cv1} \tcode{B}'', where \tcode{B}
 is a class type, can be converted to a prvalue of type ``pointer to
 \cvqual{cv2} \tcode{D}'',
-where \tcode{D} is a complete class derived\iref{class.derived}
+where \tcode{D} is a complete class
+\link{derived}{class.derived}
 from \tcode{B},
 if \cvqual{cv2} is the same cv-qualification as,
 or greater cv-qualification than, \cvqual{cv1}.
@@ -5007,7 +5008,7 @@ A prvalue of type ``pointer to member of \tcode{D} of type \cvqual{cv1}
 \tcode{T}'' can be converted to a prvalue of type ``pointer to member of
 \tcode{B} of type \cvqual{cv2} \tcode{T}'', where
 \tcode{D} is a complete class type and
-\tcode{B} is a base class\iref{class.derived} of \tcode{D},
+\tcode{B} is a \link{base class}{class.derived} of \tcode{D},
 if \cvqual{cv2} is the same cv-qualification
 as, or greater cv-qualification than, \cvqual{cv1}.
 \begin{note}
@@ -5018,7 +5019,7 @@ If no valid standard conversion
 from ``pointer to member of \tcode{B} of type \tcode{T}''
 to ``pointer to member of \tcode{D} of type \tcode{T}''
 exists\iref{conv.mem}, the program is ill-formed.
-The null member pointer value\iref{conv.mem} is converted to the null
+The \deflinkx{null member pointer value}{value!null member pointer}{conv.mem} is converted to the null
 member pointer value of the destination type. If class \tcode{B}
 contains the original member, or is a base class of the class
 containing the original member, the resulting pointer to member points
@@ -5041,7 +5042,7 @@ If the original pointer value represents the address
 then the resulting pointer value\iref{basic.compound} is unspecified.
 Otherwise, if the original pointer value points to an object \placeholder{a},
 and there is an object \placeholder{b} of type similar to \tcode{T}
-that is pointer-interconvertible\iref{basic.compound} with \placeholder{a},
+that is \deflink{pointer-interconvertible}{basic.compound} with \placeholder{a},
 the result is a pointer to \placeholder{b}.
 Otherwise, the pointer value is unchanged by the conversion.
 \begin{example}
@@ -5064,8 +5065,8 @@ result of converting the expression \tcode{v} to type \tcode{T}.
 If \tcode{T} is an lvalue reference type or an rvalue reference to function type, the result is an lvalue;
 if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the expression \tcode{v}. Conversions that can be performed explicitly
 using \keyword{reinterpret_cast} are listed below. No other conversion can
 be performed explicitly using \keyword{reinterpret_cast}.
@@ -5244,10 +5245,10 @@ The result of the expression \tcode{\keyword{const_cast}<T>(v)} is of type
 lvalue;
 if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the expression \tcode{v}.
-The temporary materialization conversion\iref{conv.rval} is not
+The \link{temporary materialization conversion}{conv.rval} is not
 performed on \tcode{v}, other than as specified below.
 Conversions that can be performed explicitly using
 \keyword{const_cast} are listed below. No other conversion shall be
@@ -5801,7 +5802,7 @@ int a[] = { co_await h() };     // error: \grammarterm{await-expression} outside
 The \keyword{sizeof} operator yields the number of bytes
 occupied by a non-potentially-overlapping object of the type
 of its operand. The operand is either an expression,
-which is an unevaluated operand\iref{term.unevaluated.operand}, or a parenthesized
+which is an \link{unevaluated operand}{term.unevaluated.operand}, or a parenthesized
 \grammarterm{nofun-type-id}.
 \indextext{type!incomplete}%
 The \keyword{sizeof} operator shall not be applied to an expression that
@@ -5858,7 +5859,7 @@ array-to-pointer\iref{conv.array}, and
 function-to-pointer\iref{conv.func} standard conversions are not
 applied to the operand of \keyword{sizeof}.
 If the operand is a prvalue,
-the temporary materialization conversion\iref{conv.rval}
+the \link{temporary materialization conversion}{conv.rval}
 is applied.
 
 \pnum
@@ -6003,7 +6004,7 @@ object created by the \grammarterm{new-expression} has a cv-qualified type.
 \end{bnf}
 
 \pnum
-If a placeholder type\iref{dcl.spec.auto} or
+If a \link{placeholder type}{dcl.spec.auto} or
 a placeholder for a deduced class type\iref{dcl.type.class.deduct}
 appears in the
 \grammarterm{type-specifier-seq} of a \grammarterm{new-type-id} or
@@ -6131,7 +6132,7 @@ is less than zero;
 
 \item
 its value is such that the size of the allocated object would exceed the
-\impldef{maximum size of an allocated object} limit\iref{implimits}; or
+\impldef{maximum size of an allocated object} \link{limit}{implimits}; or
 
 \item
 the \grammarterm{new-initializer} is a \grammarterm{braced-init-list}
@@ -6157,7 +6158,7 @@ is the null pointer value of the required result type;
 \item
 otherwise, the \grammarterm{new-expression} terminates by throwing an
 exception of a type that would match a handler\iref{except.handle} of type
-\tcode{std::bad_array_new_length}\iref{new.badlength}.
+\link{\tcode{std::bad_array_new_length}}{new.badlength}.
 \end{itemize}
 \end{itemize}
 When the value of the \grammarterm{expression} is zero, the allocation
@@ -6215,8 +6216,8 @@ the type of \tcode{\keyword{new} \keyword{int}[i][10]} is \tcode{\keyword{int} (
 A \grammarterm{new-expression} may obtain storage for the object by calling an
 allocation function\iref{basic.stc.dynamic.allocation}. If
 the \grammarterm{new-expression} terminates by throwing an exception, it
-may release storage by calling a deallocation
-function\iref{basic.stc.dynamic.deallocation}. If the allocated type
+may release storage by calling a \link{deallocation
+function}{basic.stc.dynamic.deallocation}. If the allocated type
 is a non-array type, the allocation function's name is
 \indextext{\idxcode{operator new}}%
 \indextext{\idxcode{operator delete}}%
@@ -6327,7 +6328,7 @@ the difference between the
 result of the \grammarterm{new-expression} and the address returned by the
 allocation function shall be an integral multiple of the
 strictest fundamental
-alignment requirement\iref{basic.align} of any object type whose size
+\link{alignment requirement}{basic.align} of any object type whose size
 is no greater than the size of the array being created.
 \begin{note}
 \indextext{allocation!alignment storage}%
@@ -6418,7 +6419,7 @@ invocation of \keyword{new} to another.
 \pnum
 \begin{note}
 Unless an allocation function has a non-throwing
-exception specification\iref{except.spec},
+\link{exception specification}{except.spec},
 it indicates failure to allocate storage by throwing a
 \indextext{\idxcode{bad_alloc}}%
 \indexlibraryglobal{bad_alloc}%
@@ -6634,8 +6635,8 @@ to both the allocation and deallocation functions.
 \pnum
 \indextext{expression!\idxcode{delete}}%
 \indextext{\idxcode{delete}}%
-The \grammarterm{delete-expression} operator destroys a most derived
-object\iref{intro.object} or array created by a
+The \grammarterm{delete-expression} operator destroys a
+\deflink{most derived object}{intro.object} or array created by a
 \grammarterm{new-expression}.
 
 \begin{bnf}
@@ -6738,8 +6739,8 @@ null pointer value, then:
 \item
 If the allocation call for the \grammarterm{new-expression} for the object to
 be deleted was not omitted and the allocation was not extended\iref{expr.new}, the
-\grammarterm{delete-expression} shall call a deallocation
-function\iref{basic.stc.dynamic.deallocation}. The value returned from the
+\grammarterm{delete-expression} shall call a \link{deallocation
+function}{basic.stc.dynamic.deallocation}. The value returned from the
 allocation call of the \grammarterm{new-expression} shall be passed as the
 first argument to the deallocation function.
 
@@ -7346,8 +7347,8 @@ The result of a \tcode{.*} expression
 whose second operand is a pointer to a data member is an lvalue if the first
 operand is an lvalue and an xvalue otherwise. The result of a \tcode{.*} expression whose
 second operand is a pointer to a member function is a prvalue.
-If the second operand is the null
-member pointer value\iref{conv.mem}, the behavior is undefined\ubdef{expr.mptr.oper.member.func.null}.
+If the second operand is the \deflinkx{null member pointer value}{value!null member pointer}{conv.mem},
+the behavior is undefined\ubdef{expr.mptr.oper.member.func.null}.
 
 \rSec2[expr.mul]{Multiplicative operators}%
 \indextext{expression!multiplicative operators}%
@@ -7376,7 +7377,7 @@ left-to-right.
 \pnum
 The operands of \tcode{*} and \tcode{/} shall have arithmetic or unscoped
 enumeration type; the operands of \tcode{\%} shall have integral or unscoped
-enumeration type. The usual arithmetic conversions\iref{expr.arith.conv} are performed on the
+enumeration type. The \link{usual arithmetic conversions}{expr.arith.conv} are performed on the
 operands and determine the type of the result.
 
 \pnum
@@ -7507,7 +7508,7 @@ the behavior is undefined\iref{expr.pre}.
 \pnum
 For addition or subtraction, if the expressions \tcode{P} or \tcode{Q} have
 type ``pointer to \cv{}~\tcode{T}'', where \tcode{T} and the array element type
-are not similar\iref{conv.qual}, the behavior is undefined\ubdef{expr.add.not.similar}.
+are not \deflinkx{similar}{similar types}{conv.qual}, the behavior is undefined\ubdef{expr.add.not.similar}.
 \begin{example}
 \begin{codeblock}
 int arr[5] = {1, 2, 3, 4, 5};
@@ -7598,12 +7599,12 @@ and the other is not, the program is ill-formed.
 If both operands have arithmetic types,
 or one operand has integral type and
 the other operand has unscoped enumeration type,
-the usual arithmetic conversions\iref{expr.arith.conv} are applied to the operands.
+the \link{usual arithmetic conversions}{expr.arith.conv} are applied to the operands.
 Then:
 
 \begin{itemize}
 \item
-If a narrowing conversion\iref{dcl.init.list} is required,
+If a \deflinkx{narrowing conversion}{conversion!narrowing}{dcl.init.list} is required,
 other than from an integral type to a floating-point type,
 the program is ill-formed.
 
@@ -7645,13 +7646,13 @@ the other operand is of object pointer or array type,
 array-to-pointer conversions\iref{conv.array},
 pointer conversions\iref{conv.ptr},
 and
-qualification conversions\iref{conv.qual}
+\link{qualification conversions}{conv.qual}
 are performed on both operands
 to bring them to their composite pointer type\iref{expr.type}.
 After the conversions, the operands shall have the same type.
 \begin{note}
 If both of the operands are arrays,
-array-to-pointer conversions\iref{conv.array} are not applied.
+\link{array-to-pointer conversions}{conv.array} are not applied.
 \end{note}
 In this case,
 \tcode{p <=> q} is of type \tcode{std::strong_ordering} and
@@ -7740,7 +7741,7 @@ pointer conversions\iref{conv.ptr},
 function pointer conversions\iref{conv.fctptr}, and
 qualification conversions\iref{conv.qual}
 are performed to bring
-them to their composite pointer type\iref{expr.type}.
+them to their \deflink{composite pointer type}{expr.type}.
 After conversions, the operands shall have the same type.
 
 \pnum
@@ -7833,10 +7834,10 @@ so long as neither value is an invalid pointer value.
 \indextext{comparison!pointer}%
 \indextext{comparison!pointer to function}%
 If at least one of the converted operands is a pointer,
-pointer conversions\iref{conv.ptr},
-function pointer conversions\iref{conv.fctptr}, and
-qualification conversions\iref{conv.qual}
-are performed on both operands to bring them to their composite pointer type\iref{expr.type}.
+\link{pointer conversions}{conv.ptr},
+\link{function pointer conversions}{conv.fctptr}, and
+\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}
@@ -7853,7 +7854,8 @@ the result of the comparison is unspecified.
 \item
 Otherwise, if the pointers are both null, both point to the same
 \indextext{address}%
-function, or both represent the same address\iref{basic.compound},
+function, or both
+\deflinkx{represent the same address}{represents the address}{basic.compound},
 they compare equal.
 \item
 Otherwise, the pointers compare unequal.
@@ -7898,12 +7900,12 @@ bool b1 = (bx == cx);   // unspecified
 \end{example}
 
 \item
-If both refer to (possibly different) members of the same union\iref{class.union},
+If both refer to (possibly different) members of the same \link{union}{class.union},
 they compare equal.
 
 \item
 Otherwise, two pointers to members compare equal if they would refer to the same member of
-the same most derived object\iref{intro.object} or the same subobject if
+the same \deflink{most derived object}{intro.object} or the same subobject if
 indirection with a hypothetical object of the associated
 class type were performed, otherwise they compare unequal.
 \begin{example}
@@ -8142,7 +8144,7 @@ Otherwise, if the second and third operand have different types and
 either has (possibly cv-qualified) class type, or if both
 are glvalues of the same value category and the same type except for
 cv-qualification, an attempt is made to
-form an implicit conversion sequence\iref{over.best.ics} from
+form an \link{implicit conversion sequence}{over.best.ics} from
 each of those operands to the type of the other.
 \begin{note}
 Properties such as access, whether an operand is a bit-field, or whether
@@ -8184,9 +8186,9 @@ denotes the cv-qualifiers of \tcode{T1};
 
 \item otherwise, the target type is the type that \tcode{E2} would have
 after applying the
-lvalue-to-rvalue\iref{conv.lval},
-array-to-pointer\iref{conv.array}, and
-function-to-pointer\iref{conv.func}
+\link{lvalue-to-rvalue}{conv.lval},
+\link{array-to-pointer}{conv.array}, and
+\link{function-to-pointer}{conv.func}
 standard conversions.
 \end{itemize}
 \end{itemize}
@@ -8227,8 +8229,8 @@ are used in place of the original operands for the remainder of this
 subclause.
 
 \pnum
-Array-to-pointer\iref{conv.array}
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{Array-to-pointer}{conv.array}
+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:
 
@@ -8237,16 +8239,16 @@ of the following shall hold:
 that type and the result is copy-initialized using the selected operand.
 
 \item The second and third operands have arithmetic or enumeration type;
-the usual arithmetic conversions\iref{expr.arith.conv} are performed to bring them to a common
+the \link{usual arithmetic conversions}{expr.arith.conv} are performed to bring them to a common
 type, and the result is of that type.
 
 \item One or both of the second and third operands have pointer type;
-lvalue-to-rvalue\iref{conv.lval},
-pointer\iref{conv.ptr},
-function pointer\iref{conv.fctptr}, and
-qualification conversions\iref{conv.qual}
+\link{lvalue-to-rvalue}{conv.lval},
+\link{pointer}{conv.ptr},
+\link{function pointer}{conv.fctptr}, and
+\link{qualification conversions}{conv.qual}
 are performed to bring them to their
-composite pointer type\iref{expr.type}. The result is of the composite
+\deflink{composite pointer type}{expr.type}. The result is of the composite
 pointer type.
 
 \item One or both of the second and third operands have pointer-to-member type;
@@ -8440,7 +8442,7 @@ that is not valid in the context of the evaluation\iref{basic.compound}, and
 \pnum
 \indextext{assignment!conversion by}%
 If the right operand is an expression, it is implicitly
-converted\iref{conv} to the cv-unqualified type of the left
+\link{converted}{conv} to the cv-unqualified type of the left
 operand.
 
 \pnum
@@ -8454,7 +8456,7 @@ resulting value of the bit-field is
 An assignment whose left operand is of
 a volatile-qualified type is deprecated\iref{depr.volatile.type}
 unless the (possibly parenthesized) assignment is a discarded-value expression or
-an unevaluated operand\iref{term.unevaluated.operand}.
+an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 The behavior of an expression of the form \tcode{E1 \placeholder{op}= E2}
@@ -8526,7 +8528,7 @@ The comma operator groups left-to-right.
 
 A pair of expressions separated by a comma is evaluated left-to-right;
 the left expression is
-a discarded-value expression\iref{expr.prop}.
+a \deflink{discarded-value expression}{expr.prop}.
 The left expression is sequenced before
 the right expression\iref{intro.execution}.
 \indextext{operator!side effects and comma}%
@@ -8686,7 +8688,7 @@ an arithmetic expression\iref{expr.pre} where
 \end{itemize}
 
 \item
-an lvalue-to-rvalue conversion\iref{conv.lval} unless
+an \link{lvalue-to-rvalue conversion}{conv.lval} unless
 it is applied to
 \begin{itemize}
   \item
@@ -8708,7 +8710,7 @@ that refers to a non-active member of a union or a subobject thereof;
 
 \item
 an lvalue-to-rvalue conversion that is applied to
-an object with an indeterminate value\iref{basic.indet};
+an object with an \deflinkx{indeterminate value}{value!indeterminate}{basic.indet};
 
 \item
 an invocation of an implicitly-defined copy/move constructor or
@@ -9209,7 +9211,7 @@ unscoped enumeration type, implicitly converted to a prvalue, where the converte
 Such expressions can be
 used as bit-field lengths\iref{class.bit}, as enumerator
 initializers if the underlying type is not fixed\iref{dcl.enum},
-and as alignments\iref{dcl.align}.
+and as \link{alignments}{dcl.align}.
 \end{note}
 
 \pnum
@@ -9904,7 +9906,9 @@ A function or variable is
 if it is:
 \begin{itemize}
 \item
-a constexpr function that is named by an expression\iref{basic.def.odr}
+a constexpr function that is
+\deflinkx{named by}{function!named by expression or conversion}{basic.def.odr}
+an expression
 that is potentially constant-evaluated, or
 
 \item
diff --git a/source/future.tex b/source/future.tex
index 38948be5..c594ef17 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -14,7 +14,7 @@ is defined as:
 Normative for the current revision of \Cpp{},
 but having been identified as a candidate for removal from future revisions.
 An implementation may declare library names and entities described in this Clause with the
-\tcode{deprecated} attribute\iref{dcl.attr.deprecated}.
+\link{\tcode{deprecated} attribute}{dcl.attr.deprecated}.
 
 \rSec1[depr.local]{Non-local use of TU-local entities}
 
@@ -132,11 +132,11 @@ void h(auto......);     // deprecated
 \rSec1[depr.impldec]{Implicit declaration of copy functions}
 
 \pnum
-The implicit definition of a copy constructor\iref{class.copy.ctor}
+The implicit definition of a \link{copy constructor}{class.copy.ctor}
 as defaulted is deprecated if the class has
 a user-declared copy assignment operator or
-a user-declared destructor\iref{class.dtor}.
-The implicit definition of a copy assignment operator\iref{class.copy.assign}
+a user-declared \link{destructor}{class.dtor}.
+The implicit definition of a \link{copy assignment operator}{class.copy.assign}
 as defaulted is deprecated if the class has
 a user-declared copy constructor or
 a user-declared destructor.
@@ -543,7 +543,7 @@ template<class T> struct tuple_size<const volatile T>;
 \pnum
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
-when treated as an unevaluated operand\iref{term.unevaluated.operand},
+when treated as an \deflink{unevaluated operand}{expr.context},
 then specializations of each of the two templates meet
 the \oldconcept{TransformationTrait} requirements with a base characteristic of
 \tcode{integral_constant<size_t, TS::value>}.
diff --git a/source/intro.tex b/source/intro.tex
index 3e24d06d..b5e513df 100644
--- a/source/intro.tex
+++ b/source/intro.tex
@@ -97,8 +97,8 @@ Reads of scalar objects are described in \ref{conv.lval} and
 modifications of scalar objects are described in
 \ref{expr.assign}, \ref{expr.post.incr}, and \ref{expr.pre.incr}.
 Attempts to read or modify an object of class type
-typically invoke a constructor\iref{class.ctor}
-or assignment operator\iref{class.copy.assign};
+typically invoke a \deflink{constructor}{class.ctor}
+or \link{assignment operator}{class.copy.assign};
 such invocations do not themselves constitute accesses,
 although they may involve accesses of scalar subobjects.
 \end{defnote}
@@ -246,11 +246,12 @@ implementation's output messages
 glvalue refers
 
 \begin{example}
-If a pointer\iref{dcl.ptr} \tcode{p} whose type is ``pointer to
+If a \link{pointer}{dcl.ptr} \tcode{p} whose type is ``pointer to
 class \tcode{B}'' is pointing to a base class subobject
-of class \tcode{B}, whose most derived object is of class \tcode{D}, derived
-from \tcode{B}\iref{class.derived}, the dynamic type of the
-expression \tcode{*p} is ``\tcode{D}''. References\iref{dcl.ref} are
+of class \tcode{B}, whose most derived object is of class \tcode{D},
+\link{derived}{class.derived}
+from \tcode{B}, the dynamic type of the
+expression \tcode{*p} is ``\tcode{D}''. \link{References}{dcl.ref} are
 treated similarly.
 \end{example}
 
@@ -318,7 +319,7 @@ handler functions (see \ref{support}).
 
 \indexdefn{program!ill-formed}%
 \definition{ill-formed program}{defns.ill.formed}
-program that is not well-formed\iref{defns.well.formed}
+program that is not \link{well-formed}{defns.well.formed}
 
 \indexdefn{behavior!implementation-defined}%
 \definition{implementation-defined behavior}{defns.impl.defined}
@@ -819,7 +820,7 @@ resulting in a contract violation.
 \indextext{conformance requirements!classes}%
 \indextext{conformance requirements!class templates}%
 For classes and class templates, the library Clauses specify partial
-definitions. Private members\iref{class.access} are not
+definitions. \link{Private members}{class.access} are not
 specified, but each implementation shall supply them to complete the
 definitions according to the description in the library Clauses.
 
@@ -836,7 +837,7 @@ the appropriate standard library named header unit\iref{using.headers}.
 
 \pnum
 The templates, classes, functions, and objects in the library have
-external linkage\iref{basic.link}. The implementation provides
+external \link{linkage}{basic.link}. The implementation provides
 definitions for standard library entities, as necessary, while combining
 translation units to form a complete \Cpp{}  program\iref{lex.phases}.%
 \indextext{conformance requirements!library|)}
diff --git a/source/iostreams.tex b/source/iostreams.tex
index e517bbcc..a25f980c 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -558,7 +558,7 @@ is initialized,
 returns
 \tcode{\&cout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<char>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<char>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{cout}%
@@ -591,7 +591,7 @@ is initialized,
 \tcode{cerr.flags() \& unitbuf}
 is nonzero and \tcode{cerr.tie()} returns \tcode{\&cout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<char>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<char>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{clog}%
@@ -628,7 +628,7 @@ is initialized,
 returns
 \tcode{\&wcout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<wchar_t>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<wchar_t>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{wcout}%
@@ -661,7 +661,7 @@ is initialized,
 \tcode{wcerr.flags() \& unitbuf}
 is nonzero and \tcode{wcerr.tie()} returns \tcode{\&wcout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<wchar_t>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<wchar_t>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{wclog}%
@@ -1381,7 +1381,7 @@ operate independently of the standard C streams.
 \pnum
 \returns
 \tcode{true}
-if the previous state of the standard iostream objects\iref{iostream.objects}
+if the previous state of the \link{standard iostream objects}{iostream.objects}
 was synchronized and otherwise returns
 \tcode{false}.
 The first time it is called,
@@ -1440,8 +1440,8 @@ static int xalloc();
 
 \pnum
 \remarks
-Concurrent access to this function by multiple threads does not result in a data
-race\iref{intro.multithread}.
+Concurrent access to this function by multiple threads does not result in a
+\deflink{data race}{intro.multithread}.
 \end{itemdescr}
 
 \indexlibrarymember{iword}{ios_base}%
@@ -2028,12 +2028,12 @@ locale imbue(const locale& loc);
 \pnum
 \effects
 Calls
-\tcode{ios_base::imbue(loc)}\iref{ios.base.locales}
+\libmemberrefx{ios_base::imbue}{ios_base}{imbue}\tcode{(loc)}
 and
 if
 \tcode{rdbuf() != 0}
 then
-\tcode{rdbuf()->pubimbue(loc)}\iref{streambuf.locales}.
+\tcode{rdbuf()->}\libmemberrefx{pubimbue}{basic_streambuf}{pubimbue}\tcode{(loc)}.
 
 \pnum
 \returns
@@ -3286,7 +3286,7 @@ streamsize in_avail();
 If a read position is available, returns
 \tcode{egptr() - gptr()}.
 Otherwise returns
-\tcode{showmanyc()}\iref{streambuf.virt.get}.
+\libmemberrefx{showmanyc()}{basic_streambuf}{showmanyc}.
 \end{itemdescr}
 
 \indexlibrarymember{snextc}{basic_streambuf}%
@@ -4311,7 +4311,7 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from \tcode{basic_ios}\iref{ios})
+    // types (inherited from \link{\tcode{basic_ios}}{ios})
     using char_type   = charT;
     using int_type    = traits::int_type;
     using pos_type    = traits::pos_type;
@@ -4710,7 +4710,7 @@ basic_istream& operator>>(void*& val);
 \pnum
 As in the case of the inserters, these extractors depend on the
 locale's
-\tcode{num_get<>}\iref{locale.num.get} object to perform parsing the input
+\link{\tcode{num_get<>}}{locale.num.get} object to perform parsing the input
 stream data.
 These extractors behave as formatted input functions (as described in~\ref{istream.formatted.reqmts}).  After a \tcode{sentry} object is constructed, the
 conversion occurs as if performed by the following code fragment,
@@ -4989,7 +4989,7 @@ basic_istream& operator>>(basic_streambuf<charT, traits>* sb);
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as an unformatted input function\iref{istream.unformatted}.
+Behaves as an \link{unformatted input function}{istream.unformatted}.
 If \tcode{sb} is null, calls
 \tcode{setstate(fail\-bit)},
 which may throw
@@ -5384,7 +5384,7 @@ characters and discards them.
 Characters are extracted until any of the following occurs:
 \begin{itemize}
 \item
-\tcode{n != numeric_limits<streamsize>::max()}\iref{numeric.limits}
+\tcode{n != \libmemberrefx{numeric_limits<streamsize>::max()}{numeric_limits}{max}{numeric.limits}}
 and
 \tcode{n} characters have been extracted so far;
 \item
@@ -5735,12 +5735,12 @@ template<class charT, class traits>
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as an unformatted input function\iref{istream.unformatted}, except that it does not count the number of characters extracted and
+Behaves as an \link{unformatted input function}{istream.unformatted}, except that it does not count the number of characters extracted and
 does not affect the value returned by subsequent calls to \tcode{is.gcount()}. After
 constructing a \tcode{sentry} object extracts characters as long as the next available
 character \tcode{c} is whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used by
-\tcode{sentry::sentry}\iref{istream.sentry}.
+\link{\tcode{sentry::sentry}}{istream.sentry}.
 If
 \tcode{ws}
 stops extracting characters because there are no more available it sets
@@ -5765,7 +5765,7 @@ template<class Istream, class T>
 \pnum
 \constraints
 The expression \tcode{is >> std::forward<T>(x)} is well-formed
-when treated as an unevaluated operand\iref{term.unevaluated.operand} and
+when treated as an \deflink{unevaluated operand}{expr.context} and
 \tcode{Istream} is publicly and unambiguously derived from \tcode{ios_base}.
 
 \pnum
@@ -5833,7 +5833,7 @@ explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 Initializes the base class subobjects with
 \tcode{basic_istream<charT, traits>(sb)}\iref{istream}
 and
-\tcode{basic_ostream<charT, traits>(sb)}\iref{ostream}.
+\link{\tcode{basic_ostream<charT, traits>(sb)}}{ostream}.
 
 \pnum
 \ensures
@@ -5919,7 +5919,7 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from \tcode{basic_ios}\iref{ios})
+    // types (inherited from \link{\tcode{basic_ios}}{ios})
     using char_type   = charT;
     using int_type    = traits::int_type;
     using pos_type    = traits::pos_type;
@@ -6679,7 +6679,7 @@ return *this << s;
 \end{codeblock}
 where \tcode{s} is an
 \impldef{NTCTS in \tcode{basic_ostream<charT, traits>\& op\-er\-ator<<(nullptr_t)}}
-NTCTS\iref{defns.ntcts}.
+\link{NTCTS}{defns.ntcts}.
 \end{itemdescr}
 
 \rSec4[ostream.inserters.character]{Character inserter function templates}
@@ -6698,7 +6698,7 @@ template<class traits>
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as a formatted output function\iref{ostream.formatted.reqmts}
+Behaves as a \link{formatted output function}{ostream.formatted.reqmts}
 of \tcode{out}. Constructs a character sequence \tcode{seq}.
 If \tcode{c} has type
 \tcode{char}
@@ -7443,7 +7443,7 @@ a specialization of the \tcode{basic_string} template\iref{strings}.
 \pnum
 \effects
 The expression \tcode{in >> get_money(mon, intl)} described below
-behaves as a formatted input function\iref{istream.formatted.reqmts}.
+behaves as a \link{formatted input function}{istream.formatted.reqmts}.
 
 \pnum
 \returns
@@ -7488,7 +7488,7 @@ a specialization of the \tcode{basic_string} template\iref{strings}.
 An object of unspecified type such that if
 \tcode{out} is an object of type \tcode{basic_ostream<charT, traits>}
 then the expression \tcode{out << put_money(mon, intl)} behaves as a
-formatted output function\iref{ostream.formatted.reqmts} that calls
+\link{formatted output function}{ostream.formatted.reqmts} that calls
 \tcode{f(out, mon, intl)}, where the function \tcode{f} is defined as:
 
 \begin{codeblock}
@@ -7612,7 +7612,7 @@ of \tcode{basic_ostream} with member type \tcode{char_type} the same as
 \tcode{charT} and with member type \tcode{traits_type}, which in the second and third
 forms is the same as \tcode{traits}, then the expression
 \tcode{out << quoted(s, delim, escape)}
-behaves as a formatted output function\iref{ostream.formatted.reqmts}
+behaves as a \link{formatted output function}{ostream.formatted.reqmts}
 of \tcode{out}. This forms a character sequence \tcode{seq}, initially
 consisting of the following elements:
 \begin{itemize}
@@ -14091,7 +14091,7 @@ denotes a possibly const encoded character type\iref{temp.deduct}.
 
 \pnum
 \begin{note}
-See path conversions\iref{fs.path.cvt}
+See \link{path conversions}{fs.path.cvt}
 for how the value types above and their encodings convert to
 \tcode{path::value_type} and its encoding.
 \end{note}
@@ -14703,7 +14703,7 @@ and print functions\iref{print.fun}.
 
 \pnum
 Generic format observer functions return strings formatted according to the
-generic pathname format\iref{fs.path.generic}.
+\link{generic pathname format}{fs.path.generic}.
 A single slash (\tcode{'/'}) character is used as
 the \grammarterm{directory-separator}.
 
@@ -15259,11 +15259,11 @@ If normalization\iref{fs.path.generic} is needed
 \indexlibrarymember{path}{iterator}%
 \pnum
 Path iterators iterate over the elements of the pathname
-in the generic format\iref{fs.path.generic}.
+in the \link{generic format}{fs.path.generic}.
 
 \pnum
 A \tcode{path::iterator} is a constant iterator meeting all the
-requirements of a bidirectional iterator\iref{bidirectional.iterators}
+requirements of a \link{bidirectional iterator}{bidirectional.iterators}
 except that,
 for dereferenceable iterators \tcode{a} and \tcode{b}
 of type \tcode{path::iterator}
@@ -16620,7 +16620,7 @@ If a file  is removed from or added to a directory after the
 construction of a \tcode{directory_iterator} for the directory, it is
 unspecified whether or not subsequently incrementing the iterator will ever
 result in an iterator referencing the removed or added directory entry. See
-POSIX \tcode{readdir}.
+POSIX \weblink{\tcode{readdir}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/readdir.html}.
 \end{note}
 
 \rSec3[fs.dir.itr.members]{Members}
@@ -16712,7 +16712,7 @@ directory_iterator& increment(error_code& ec);
 \pnum
 \effects
 As specified for the prefix increment operation of
-Input iterators\iref{input.iterators}.
+\link{Input iterators}{input.iterators}.
 
 \pnum
 \returns
@@ -17024,7 +17024,7 @@ recursive_directory_iterator& increment(error_code& ec);
 \pnum
 \effects
 As specified for the prefix increment operation of
-Input iterators\iref{input.iterators},
+\link{Input iterators}{input.iterators},
 except that:
 
 \begin{itemize}
@@ -17615,7 +17615,7 @@ void filesystem::create_directory_symlink(const path& to, const path& new_symlin
 \begin{itemdescr}
 \pnum
 \effects
-Establishes the postcondition, as if by POSIX \tcode{symlink}.
+Establishes the postcondition, as if by POSIX \weblink{\tcode{symlink}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html}.
 
 \pnum
 \ensures
@@ -17691,7 +17691,7 @@ void filesystem::create_symlink(const path& to, const path& new_symlink,
 \begin{itemdescr}
 \pnum
 \effects
-Establishes the postcondition, as if by POSIX \tcode{symlink}.
+Establishes the postcondition, as if by POSIX \weblink{\tcode{symlink}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html}.
 
 \pnum
 \ensures
@@ -17724,7 +17724,7 @@ path filesystem::current_path(error_code& ec);
 \returns
 The absolute path of the current working directory,
   whose pathname in the native format is
-  obtained as if by POSIX \tcode{getcwd}.
+  obtained as if by POSIX \weblink{\tcode{getcwd}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/getcwd.html}.
   The signature with argument \tcode{ec} returns \tcode{path()} if an
   error occurs.
 
@@ -17755,7 +17755,7 @@ void filesystem::current_path(const path& p, error_code& ec) noexcept;
 \begin{itemdescr}
 \pnum
 \effects
-Establishes the postcondition, as if by POSIX \tcode{chdir}.
+Establishes the postcondition, as if by POSIX \weblink{\tcode{chdir}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html}.
 
 \pnum
 \ensures
@@ -17866,7 +17866,7 @@ If \tcode{exists(p)} is \tcode{false}, an error is reported\iref{fs.err.report}.
 \item
   If \tcode{is_regular_file(p)}, the size in bytes of the file
   \tcode{p} resolves to, determined as if by the value of the POSIX \tcode{stat}
-  class member \tcode{st_size} obtained as if by POSIX \tcode{stat}.
+  class member \tcode{st_size} obtained as if by POSIX \weblink{\tcode{stat}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/stat.html}.
 \item
   Otherwise, the result is \impldef{result of \tcode{filesystem::file_size}}.
 \end{itemize}
@@ -18248,7 +18248,7 @@ void filesystem::last_write_time(const path& p, file_time_type new_time,
 \pnum
 \effects
 Sets the time of last data modification of the file
-  resolved to by \tcode{p} to \tcode{new_time}, as if by POSIX \tcode{futimens}.
+  resolved to by \tcode{p} to \tcode{new_time}, as if by POSIX \weblink{\tcode{futimens}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/futimens.html}.
 
 \pnum
 \throws
diff --git a/source/iterators.tex b/source/iterators.tex
index 8c8469c0..fe0df33f 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -6746,7 +6746,7 @@ ostream_iterator& operator++(int);
 The
 class template
 \tcode{istreambuf_iterator}
-defines an input iterator\iref{input.iterators} that
+defines an \link{input iterator}{input.iterators} that
 reads successive
 \textit{characters}
 from the streambuf for which it was constructed.
@@ -6871,7 +6871,6 @@ constexpr istreambuf_iterator(default_sentinel_t) noexcept;
 Initializes \tcode{sbuf_} with \keyword{nullptr}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(istream_type& s) noexcept;
@@ -6883,7 +6882,6 @@ istreambuf_iterator(istream_type& s) noexcept;
 Initializes \tcode{sbuf_} with \tcode{s.rdbuf()}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(streambuf_type* s) noexcept;
@@ -6895,7 +6893,6 @@ istreambuf_iterator(streambuf_type* s) noexcept;
 Initializes \tcode{sbuf_} with \tcode{s}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(const @\placeholder{proxy}@& p) noexcept;
@@ -7046,7 +7043,6 @@ is not a null pointer.
 Initializes \tcode{sbuf_} with \tcode{s.rdbuf()}.
 \end{itemdescr}
 
-
 \indexlibraryctor{ostreambuf_iterator}%
 \begin{itemdecl}
 ostreambuf_iterator(streambuf_type* s) noexcept;
diff --git a/source/lex.tex b/source/lex.tex
index f96ec6b6..3c9f22b7 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -29,8 +29,8 @@
 \indextext{compilation!separate|(}%
 The text of the program is kept in units called
 \defnx{source files}{source file} in this document.
-A source file together with all the headers\iref{headers}
-and source files included\iref{cpp.include} via the preprocessing
+A source file together with all the \link{headers}{headers}
+and source files \link{included}{cpp.include} via the preprocessing
 directive \tcode{\#include}, less any source lines skipped by any of the
 conditional inclusion\iref{cpp.cond} preprocessing directives,
 as modified by the implementation-defined behavior of any
@@ -2324,7 +2324,7 @@ operator ""@\placeholder{X}@(@\placeholder{str}{}@, @\placeholder{len}{}@)
 \pnum
 If \placeholder{L} is a \grammarterm{user-defined-character-literal}, let \placeholder{ch} be the
 literal without its \grammarterm{ud-suffix}.
-\placeholder{S} shall contain a literal operator\iref{over.literal} whose only parameter has
+\placeholder{S} shall contain a \deflinkx{literal operator}{literal!operator}{over.literal} whose only parameter has
 the type of \placeholder{ch} and the
 literal \placeholder{L} is treated as a call
 of the form
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 99420d7c..f7e65073 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -101,7 +101,7 @@ including formatting, internationalization support and
 regular expression matching and searching.
 
 \pnum
-The numerics library\iref{numerics} provides
+The \link{numerics library}{numerics} provides
 numeric algorithms and complex number components that extend support for numeric processing.
 The
 \tcode{valarray}
@@ -521,8 +521,8 @@ of other standards\iref{intro.refs}.
 Subclause \ref{conventions} describes several editorial conventions used to describe the contents
 of the \Cpp{} standard library.
 These conventions are for describing
-implementation-defined types\iref{type.descriptions},
-and member functions\iref{functions.within.classes}.
+\link{implementation-defined types}{type.descriptions},
+and \link{member functions}{functions.within.classes}.
 
 \rSec3[expos.only.entity]{Exposition-only entities, etc.}
 
@@ -651,7 +651,7 @@ and \ref{depr} are
 Each bitmask type can be implemented as an
 enumerated type that overloads certain operators, as an integer type,
 or as a
-\tcode{bitset}\iref{template.bitset}.
+\link{\tcode{bitset}}{template.bitset}.
 \indextext{type!enumerated}%
 
 \pnum
@@ -777,7 +777,7 @@ locale.
 \item
 A
 \defn{character sequence}
-is an array object\iref{dcl.array} \tcode{\placeholdernc{A}} that
+is an \link{array object}{dcl.array} \tcode{\placeholdernc{A}} that
 can be declared as
 \tcode{\placeholdernc{T\;A}[\placeholder{N}]},
 where \tcode{\placeholder{T}} is any of the types
@@ -968,7 +968,7 @@ signatures, or for virtual destructors that can be generated by default.
 \pnum
 \ref{\firstlibchapter} through \ref{\lastlibchapter} and
 \ref{depr} do not specify the representation of classes, and intentionally
-omit specification of class members\iref{class.mem}. An implementation may
+omit specification of \link{class members}{class.mem}. An implementation may
 define static or non-static class members, or both, as needed to implement the
 semantics of the member functions specified in \ref{\firstlibchapter}
 through \ref{\lastlibchapter} and \ref{depr}.
@@ -1380,10 +1380,10 @@ std::vector<int> vi;            // OK
 Except as noted in \ref{library} through \ref{\lastlibchapter}
 and \ref{depr}, the contents of each header \tcode{c\placeholder{name}} is
 the same as that of the corresponding header \tcode{\placeholder{name}.h} as
-specified in the C standard library\iref{intro.refs}.
+specified in the \deflinkx{C standard library}{C!standard library}{intro.refs}.
 In the \Cpp{} standard library, however, the
 declarations (except for names which are defined as macros in C) are within
-namespace scope\iref{basic.scope.namespace} of the namespace \tcode{std}.
+\link{namespace scope}{basic.scope.namespace} of the namespace \tcode{std}.
 It is unspecified whether these names (including any overloads added in
 \ref{\firstlibchapter} through \ref{\lastlibchapter} and \ref{depr})
 are first declared within the global namespace scope
@@ -1701,8 +1701,8 @@ a hosted implementation.
 \pnum
 Subclause \ref{using} describes how a \Cpp{} program gains access to the facilities of the
 \Cpp{} standard library. \ref{using.headers} describes effects during translation
-phase 4, while~\ref{using.linkage} describes effects during phase
-8\iref{lex.phases}.
+phase 4, while~\ref{using.linkage} describes effects during \link{phase
+8}{lex.phases}.
 
 \rSec3[using.headers]{Headers}
 
@@ -1745,7 +1745,7 @@ declared in that header. No diagnostic is required.
 \rSec3[using.linkage]{Linkage}
 
 \pnum
-Entities in the \Cpp{} standard library have external linkage\iref{basic.link}.
+Entities in the \Cpp{} standard library have \link{external linkage}{basic.link}.
 Unless otherwise specified, objects and functions have the default
 \tcode{extern "C++"}
 linkage\iref{dcl.link}.
@@ -1779,8 +1779,8 @@ the program prior to program startup.
 \indextext{startup!program}%
 \pnum
 See also
-replacement functions\iref{replacement.functions},
-runtime changes\iref{handler.functions}.
+\link{replacement functions}{replacement.functions},
+\link{runtime changes}{handler.functions}.
 
 \rSec2[utility.requirements]{Requirements on types and expressions}
 
@@ -1947,13 +1947,13 @@ evaluated in the context described below, and
 
 \pnum
 The context in which \tcode{swap(t, u)} and \tcode{swap(u, t)} are evaluated shall
-ensure that a binary non-member function named ``swap'' is selected via overload
-resolution\iref{over.match} on a candidate set that includes:
+ensure that a binary non-member function named ``swap'' is selected via \link{overload
+resolution}{over.match} on a candidate set that includes:
 \begin{itemize}
 \item the two \tcode{swap} function templates defined in
 \libheaderref{utility} and
 
-\item the lookup set produced by argument-dependent lookup\iref{basic.lookup.argdep}.
+\item the lookup set produced by \link{argument-dependent lookup}{basic.lookup.argdep}.
 \end{itemize}
 \begin{note}
 If \tcode{T} and \tcode{U} are both fundamental types or arrays of
@@ -2056,8 +2056,9 @@ operations involving erroneous values can cause erroneous behavior\iref{basic.in
 \end{note}
 
 \pnum
-An object \tcode{p} of type \tcode{P} can be contextually converted to
-\tcode{bool}\iref{conv}. The effect shall be as if \tcode{p != nullptr}
+An object \tcode{p} of type \tcode{P} can be
+\deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv}.
+The effect shall be as if \tcode{p != nullptr}
 had been evaluated in place of \tcode{p}.
 
 \pnum
@@ -2160,7 +2161,7 @@ as the memory allocation and deallocation primitives for it. All of the
 string types\iref{strings},
 containers\iref{containers} (except \tcode{array} and \tcode{inplace_vector}),
 string buffers and string streams\iref{input.output}, and
-\tcode{match_results}\iref{re} are parameterized in terms of
+\link{\tcode{match_results}}{re} are parameterized in terms of
 allocators.
 
 \pnum
@@ -2986,7 +2987,7 @@ If \tcode{X} is an allocator class for type \tcode{T},
 whether or not \tcode{T} is a complete type:
 \begin{itemize}
 \item \tcode{X} is a complete type, and
-\item all the member types of \tcode{allocator_traits<X>}\iref{allocator.traits}
+\item all the member types of \link{\tcode{allocator_traits<X>}}{allocator.traits}
   other than \tcode{value_type} are complete types.
 \end{itemize}
 
@@ -2997,11 +2998,11 @@ whether or not \tcode{T} is a complete type:
 \pnum
 Subclause \ref{constraints} describes restrictions on \Cpp{} programs that use the facilities of
 the \Cpp{} standard library. The following subclauses specify constraints on the
-program's use of namespaces\iref{namespace.std}, its use of various reserved
-names\iref{reserved.names}, its use of headers\iref{alt.headers}, its use of
+program's use of \link{namespaces}{namespace.std}, its use of various \link{reserved
+names}{reserved.names}, its use of \link{headers}{alt.headers}, its use of
 standard library classes as base classes\iref{derived.classes}, its
-definitions of replacement functions\iref{replacement.functions}, and its
-installation of handler functions during execution\iref{handler.functions}.
+definitions of \link{replacement functions}{replacement.functions}, and its
+installation of \link{handler functions}{handler.functions} during execution.
 
 \rSec3[namespace.constraints]{Namespace use}
 
@@ -3412,7 +3413,7 @@ are reserved for use by \Cpp{} implementations.
 If a file with a name
 equivalent to the derived file name for one of the \Cpp{} standard library headers
 is not provided as part of the implementation, and a file with that name
-is placed in any of the standard places for a source file to be included\iref{cpp.include},
+is placed in any of the standard places for a source file to be \link{included}{cpp.include},
 the behavior is undefined.%
 \indextext{source file}%
 \indextext{undefined}
@@ -3583,7 +3584,7 @@ specified as being shareable without data races or the user supplies a locking m
 
 \pnum
 If an object of a standard library type is accessed, and
-the beginning of the object's lifetime\iref{basic.life}
+the beginning of the object's \link{lifetime}{basic.life}
 does not happen before the access, or
 the access does not happen before the end of the object's lifetime,
 the behavior is undefined unless otherwise specified.
@@ -3649,7 +3650,7 @@ Every such entity shall be defined such that any header that defines it may be
 included after any other header that also defines it\iref{basic.def.odr}.
 
 \pnum
-The C standard library headers\iref{support.c.headers}
+The \link{C standard library headers}{support.c.headers}
 shall include only their corresponding \Cpp{} standard library header,
 as described in~\ref{headers}.
 
@@ -3677,7 +3678,7 @@ explicitly stated otherwise.
 It is unspecified whether any
 non-member
 functions in the \Cpp{} standard library are defined as
-inline\iref{dcl.inline}.
+\link{inline}{dcl.inline}.
 
 \pnum
 A call to a non-member function signature
@@ -3714,7 +3715,7 @@ includes the associated namespaces of \tcode{value}'s type.
 
 \pnum
 It is unspecified whether any member functions in the \Cpp{} standard library are defined as
-inline\iref{dcl.inline}.
+\link{inline}{dcl.inline}.
 
 \pnum
 For a non-virtual member function described in the \Cpp{} standard library,
@@ -3803,8 +3804,8 @@ the behavior is undefined unless otherwise specified.
 \rSec3[res.on.data.races]{Data race avoidance}
 
 \pnum
-This subclause specifies requirements that implementations shall meet to prevent data
-races\iref{intro.multithread}.
+This subclause specifies requirements that implementations shall meet to prevent
+\deflinkx{data races}{data race}{intro.multithread}.
 Every standard library function shall meet each requirement unless otherwise specified.
 Implementations may prevent data races in cases other than those specified below.
 
@@ -3847,7 +3848,7 @@ not visible to users and are protected against data races.
 \pnum
 Unless otherwise specified, \Cpp{} standard library functions shall perform all operations
 solely within the current thread if those operations have effects that are
-visible\iref{intro.multithread} to users.
+\deflinkx{visible}{side effects!visible}{intro.multithread} to users.
 
 \pnum
 \begin{note}
@@ -3962,7 +3963,7 @@ potentially-throwing exception specification} exceptions.
 \begin{footnote}
 In particular, they
 can report a failure to allocate storage by throwing an exception of type
-\tcode{bad_alloc},
+\link{\tcode{bad_alloc}}{bad.alloc},
 or a class derived from
 \tcode{bad_alloc}\iref{bad.alloc}.
 \end{footnote}
diff --git a/source/limits.tex b/source/limits.tex
index e0596a32..877f21f3 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -120,7 +120,7 @@ during template argument deduction\iref{temp.deduct} [1\,024].
 \item%
 Handlers per try block\iref{except.handle} [256].
 \item%
-Number of placeholders\iref{func.bind.place} [10].
+Number of \link{placeholders}{func.bind.place} [10].
 \item%
 Number of hazard-protectable possibly-reclaimable objects\iref{saferecl.hp.general} [256].
 
diff --git a/source/numerics.tex b/source/numerics.tex
index f228a4ed..935afa2b 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -157,8 +157,8 @@ floating-point evaluation in constant expressions.
 \rSec2[cfenv.thread]{Threads}
 
 \pnum
-The floating-point environment has thread storage
-duration\iref{basic.stc.thread}. The initial state for a thread's floating-point
+The floating-point environment has \deflinkx{thread storage duration}{storage duration!thread}{basic.stc.thread}.
+The initial state for a thread's floating-point
 environment is the state of the floating-point environment of the thread that constructs
 the corresponding \tcode{thread} object\iref{thread.thread.class}
 or \tcode{jthread} object\iref{thread.jthread.class}
@@ -1571,17 +1571,17 @@ on an instantiated template $T$:
     A template argument corresponding to a template parameter
     named \tcode{Sseq}
     shall meet the requirements
-    of seed sequence\iref{rand.req.seedseq}.
+    of \link{seed sequence}{rand.req.seedseq}.
   \item
     A template argument corresponding to a template parameter
     named \tcode{URBG}
     shall meet the requirements
-    of uniform random bit generator\iref{rand.req.urng}.
+    of \link{uniform random bit generator}{rand.req.urng}.
   \item
     A template argument corresponding to a template parameter
     named \tcode{Engine}
     shall meet the requirements
-    of random number engine\iref{rand.req.eng}.
+    of \link{random number engine}{rand.req.eng}.
   \item
     If a template argument corresponding to a template parameter
     named \tcode{RealType}
@@ -1702,7 +1702,7 @@ In \tref{rand.req.seedseq} and throughout this subclause:
 \endhead
 \tcode{S::result_type}
   & \tcode{T}
-  & \tcode{T} is an unsigned integer type\iref{basic.fundamental}
+  & \tcode{T} is an \deflinkx{unsigned integer type}{type!unsigned integer}{basic.fundamental}
     of at least 32 bits.
   &
   \\ \rowsep
@@ -1867,7 +1867,7 @@ An engine's state may be established via
 \pnum
 A class \tcode{E}
 that meets the requirements
-of a uniform random bit generator\iref{rand.req.urng}
+of a \link{uniform random bit generator}{rand.req.urng}
 also meets the requirements
 of a \term{random number engine}
 if the expressions shown
@@ -1888,7 +1888,7 @@ In \tref{rand.req.eng} and throughout this subclause:
     \tcode{s} is a value of \tcode{T};
   \item
     \tcode{q} is an lvalue
-    meeting the requirements of a seed sequence\iref{rand.req.seedseq};
+    meeting the requirements of a \link{seed sequence}{rand.req.seedseq};
   \item
     \tcode{z} is a value
     of type \tcode{unsigned long long};
@@ -2322,7 +2322,7 @@ In \tref{rand.req.dist} and throughout this subclause,
   \item
     \tcode{g}, \tcode{g1}, and \tcode{g2} are lvalues of a type
     meeting the requirements
-    of a uniform random bit generator\iref{rand.req.urng};
+    of a \link{uniform random bit generator}{rand.req.urng};
   \item
     \tcode{os} is an lvalue of the type of some class template specialization
     \tcode{basic_ostream<charT,} \tcode{traits>};
@@ -2354,7 +2354,7 @@ according to \ref{strings} and \ref{input.output}.
 \endhead
 \tcode{D::result_type}
   & \tcode{T}
-  & \tcode{T} is an arithmetic type\iref{basic.fundamental}.
+  & \tcode{T} is an \deflinkx{arithmetic type}{type!arithmetic}{basic.fundamental}.
   &
   \\ \rowsep
 \tcode{D::param_type}
@@ -2596,7 +2596,7 @@ reference to the type of \tcode{is}.
 Each type instantiated
 from a class template specified in \ref{rand.eng}
 meets the requirements
-of a random number engine\iref{rand.req.eng} type.
+of a \link{random number engine}{rand.req.eng} type.
 
 \pnum
 Except where specified otherwise,
@@ -3394,7 +3394,7 @@ The counter is the value $Z$ introduced at the beginning of this subclause.
 Each type instantiated
 from a class template specified in \ref{rand.adapt}
 meets the requirements
-of a random number engine adaptor\iref{rand.req.adapt} type.
+of a \link{random number engine adaptor}{rand.req.adapt} type.
 
 \pnum
 Except where specified otherwise,
@@ -4488,7 +4488,7 @@ than the output when computing $S$.
 Each type instantiated
 from a class template specified in \ref{rand.dist}
 meets the requirements
-of a random number distribution\iref{rand.req.dist} type.
+of a \link{random number distribution}{rand.req.dist} type.
 
 \pnum
 Descriptions are provided in \ref{rand.dist}
@@ -5342,6 +5342,7 @@ p(x\,|\,\alpha,\beta) =
 
 \indexlibraryglobal{gamma_distribution}%
 \indexlibrarymember{result_type}{gamma_distribution}%
+\indexlibrary{\idxcode{gamma_distribution}}%
 \begin{codeblock}
 namespace std {
   template<class RealType = double>
@@ -5385,7 +5386,6 @@ namespace std {
 }
 \end{codeblock}
 
-
 \indexlibraryctor{gamma_distribution}%
 \begin{itemdecl}
 explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
@@ -5492,7 +5492,7 @@ namespace std {
 \indexlibraryctor{weibull_distribution}%
 \begin{itemdecl}
 explicit weibull_distribution(RealType a, RealType b = 1.0);
-\end{itemdecl}%
+\end{itemdecl}
 
 \begin{itemdescr}
 \pnum
@@ -5602,7 +5602,6 @@ namespace std {
 }
 \end{codeblock}
 
-
 \indexlibraryctor{extreme_value_distribution}%
 \begin{itemdecl}
 explicit extreme_value_distribution(RealType a, RealType b = 1.0);
@@ -5726,7 +5725,6 @@ namespace std {
 }
 \end{codeblock}
 
-
 \indexlibraryctor{normal_distribution}%
 \begin{itemdecl}
 explicit normal_distribution(RealType mean, RealType stddev = 1.0);
@@ -5930,7 +5928,6 @@ namespace std {
 }
 \end{codeblock}
 
-
 \indexlibraryctor{chi_squared_distribution}%
 \begin{itemdecl}
 explicit chi_squared_distribution(RealType n);
@@ -6124,7 +6121,6 @@ namespace std {
 }
 \end{codeblock}
 
-
 \indexlibraryctor{fisher_f_distribution}%
 \begin{itemdecl}
 explicit fisher_f_distribution(RealType m, RealType n = 1);
@@ -6227,7 +6223,6 @@ namespace std {
 }
 \end{codeblock}
 
-
 \indexlibraryctor{student_t_distribution}%
 \begin{itemdecl}
 explicit student_t_distribution(RealType n);
@@ -6343,7 +6338,7 @@ namespace std {
 }
 \end{codeblock}
 
-\indexlibraryctor{discrete_distribution}
+\indexlibraryctor{discrete_distribution}%
 \begin{itemdecl}
 discrete_distribution();
 \end{itemdecl}
@@ -7194,7 +7189,7 @@ objects.
 
 \pnum
 These library functions are permitted to throw a
-\tcode{bad_alloc}\iref{bad.alloc} exception if there are not sufficient resources available
+\link{\tcode{bad_alloc}}{bad.alloc} exception if there are not sufficient resources available
 to carry out the operation.
 Note that the exception is not mandated.
 
@@ -7362,7 +7357,7 @@ explicit valarray(size_t n);
 \pnum
 \effects
 Constructs a \tcode{valarray} that has length \tcode{n}.
-Each element of the array is value-initialized\iref{dcl.init}.
+Each element of the array is \deflinkx{value-initialized}{value-initialization}{dcl.init}.
 \end{itemdescr}
 
 \indexlibraryctor{valarray}%
@@ -7622,7 +7617,7 @@ and other techniques to generate efficient
 \pnum
 The reference returned by the subscript operator for an array shall
 be valid until the member function
-\tcode{resize(size_t, T)}\iref{valarray.members} is called for that array or until the lifetime of
+\libmemberrefx{resize(size_t, T)}{valarray}{resize} is called for that array or until the lifetime of
 that array ends, whichever happens first.
 \end{itemdescr}
 
@@ -8094,7 +8089,7 @@ places, with zero fill.
 \pnum
 \begin{example}
 If the argument has the value $-2$,
-the first two elements of the result will be value-initialized\iref{dcl.init}; the third element of the result will be assigned the value
+the first two elements of the result will be \deflinkx{value-initialized}{value-initialization}{dcl.init}; the third element of the result will be assigned the value
 of the first element of \tcode{*this}; etc.
 \end{example}
 \end{itemdescr}
@@ -9618,12 +9613,12 @@ The contents and meaning of the header \libheader{cmath}
 are a subset of the C standard library header \libheader{math.h} and
 only the declarations shown in the synopsis above are present,
 with the addition of
-a three-dimensional hypotenuse function\iref{c.math.hypot3},
-a linear interpolation function\iref{c.math.lerp}, and
+a \link{three-dimensional hypotenuse function}{c.math.hypot3},
+a \link{linear interpolation function}{c.math.lerp}, and
 the mathematical special functions described in \ref{sf.cmath}.
 \begin{note}
 Several functions have additional overloads in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \pnum
@@ -9687,7 +9682,7 @@ for the functions \tcode{abs}, \tcode{labs}, and \tcode{llabs}, respectively.
 If \tcode{abs} is called with an argument of type \tcode{X}
 for which \tcode{is_unsigned_v<X>} is \tcode{true} and
 if \tcode{X} cannot be converted to \tcode{int}
-by integral promotion\iref{conv.prom}, the program is ill-formed.
+by \link{integral promotion}{conv.prom}, the program is ill-formed.
 \begin{note}
 Allowing arguments that can be promoted to \tcode{int}
 provides compatibility with C.
diff --git a/source/overloading.tex b/source/overloading.tex
index d25bf7fe..869dca71 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -74,7 +74,7 @@ Overload resolution selects the function to call in seven distinct
 contexts within the language:
 \begin{itemize}
 \item
-invocation of a function named in the function call syntax\iref{over.call.func};
+invocation of a function named in the \link{function call syntax}{over.call.func};
 \item
 invocation of a function call operator, a pointer-to-function
 conversion function, a reference-to-pointer-to-function conversion
@@ -88,14 +88,14 @@ invocation of a constructor for default- or direct-initialization\iref{dcl.init}
 of a class object\iref{over.match.ctor};
 \item
 invocation of a user-defined conversion for
-copy-initialization\iref{dcl.init} of a class object\iref{over.match.copy};
+\deflink{copy-initialization}{dcl.init} of a class object\iref{over.match.copy};
 \item
 invocation of a conversion function for initialization of an object of a
 non-class type from an expression of class type\iref{over.match.conv}; and
 \item
 invocation of a conversion function for conversion
 in which a reference\iref{dcl.init.ref}
-will be directly bound\iref{over.match.ref}.
+will be \link{directly bound}{over.match.ref}.
 \end{itemize}
 
 Each of these contexts defines the set of candidate functions and
@@ -113,7 +113,7 @@ conditions) is selected to form a set of
 viable functions\iref{over.match.viable}.
 \item
 Then the best viable function is selected based on the
-implicit conversion sequences\iref{over.best.ics} needed to
+\link{implicit conversion sequences}{over.best.ics} needed to
 match each argument to the corresponding parameter of each
 viable function.
 \end{itemize}
@@ -124,7 +124,7 @@ resolution succeeds and produces it as the result.
 Otherwise
 overload resolution fails and the invocation is ill-formed.
 When overload resolution succeeds,
-and the best viable function is not accessible\iref{class.access} in the context
+and the best viable function is not \link{accessible}{class.access} in the context
 in which it is used,
 the program is ill-formed.
 
@@ -238,7 +238,7 @@ as long as in all other respects the argument can be
 converted to the type of the implicit object parameter.
 \begin{note}
 The fact that such an argument is an rvalue does not
-affect the ranking of implicit conversion sequences\iref{over.ics.rank}.
+affect the \link{ranking}{over.ics.rank} of implicit conversion sequences.
 \end{note}
 
 \pnum
@@ -361,7 +361,7 @@ B b3 = C();                             // calls \#4
 \indextext{overloading!resolution!function call syntax|(}
 
 \pnum
-In a function call\iref{expr.call}
+In a \link{function call}{expr.call}
 \begin{ncsimplebnf}
 postfix-expression \terminal{(} \opt{expression-list} \terminal{)}
 \end{ncsimplebnf}
@@ -958,7 +958,7 @@ in each case using the selected rewritten \tcode{\keyword{operator}==} candidate
 If a built-in candidate is selected by overload resolution, the
 operands of class type are converted to the types of the corresponding parameters
 of the selected operation function, except that the second standard conversion
-sequence of a user-defined conversion sequence\iref{over.ics.user} is not applied.
+sequence of a \link{user-defined conversion sequence}{over.ics.user} is not applied.
 Then the operator is treated as the corresponding
 built-in operator and interpreted according to \ref{expr.compound}.
 \begin{example}
@@ -1041,10 +1041,10 @@ void B::f() {
 \indextext{overloading!resolution!initialization}
 
 \pnum
-When objects of class type are direct-initialized\iref{dcl.init},
+When objects of class type are \deflinkx{direct-initialized}{direct-initialization}{dcl.init},
 copy-initialized from an expression of the same or a
 derived class type\iref{dcl.init},
-or default-initialized\iref{dcl.init},
+or \deflinkx{default-initialized}{default-initialization}{dcl.init},
 overload resolution selects the constructor.
 For direct-initialization or default-initialization
 (including default-initialization in the context of copy-list-initialization),
@@ -1836,7 +1836,7 @@ Third, for
 \tcode{F}
 to be a viable function, there shall exist for each
 argument an
-implicit conversion sequence\iref{over.best.ics} that
+\deflinkx{implicit conversion sequence}{conversion sequence!implicit}{over.best.ics} that
 converts that argument to the corresponding parameter of
 \tcode{F}.
 If the parameter has reference type, the implicit conversion sequence
@@ -1900,8 +1900,8 @@ float x = a;        // ambiguous: both possibilities require conversions,
 \end{example}
 or, if not that,
 
-\item the context is an initialization by conversion function for direct
-reference binding\iref{over.match.ref} of a reference to function type, the
+\item the context is an initialization by conversion function for \link{direct
+reference binding}{over.match.ref} of a reference to function type, the
 return type of $\tcode{F}_1$ is the same kind of reference (lvalue or rvalue)
 as the reference being initialized, and the return type of $\tcode{F}_2$ is not
 \begin{example}
@@ -2031,7 +2031,7 @@ $\tcode{F}_1$ is generated from a
 and $\tcode{F}_2$ is not, or, if not that,
 
 \item
-$\tcode{F}_1$ is the copy deduction candidate\iref{over.match.class.deduct}
+$\tcode{F}_1$ is the \deflink{copy deduction candidate}{over.match.class.deduct}
 and $\tcode{F}_2$ is not, or, if not that,
 
 \item
@@ -2157,7 +2157,7 @@ parameter.
 \begin{note}
 Other properties, such as the lifetime, storage duration, linkage,
 alignment, accessibility of the argument, whether the argument is a bit-field,
-and whether a function is deleted\iref{dcl.fct.def.delete}, are ignored.
+and whether a function is \link{deleted}{dcl.fct.def.delete}, are ignored.
 So, although an implicit
 conversion sequence can be defined for a given argument-parameter
 pair, the conversion from the argument to the parameter might still
@@ -2170,11 +2170,11 @@ well-formed implicit conversion
 sequence is one of the following forms:
 \begin{itemize}
 \item
-a standard conversion sequence\iref{over.ics.scs},
+a \link{standard conversion sequence}{over.ics.scs},
 \item
-a user-defined conversion sequence\iref{over.ics.user}, or
+a \link{user-defined conversion sequence}{over.ics.user}, or
 \item
-an ellipsis conversion sequence\iref{over.ics.ellipsis}.
+an \link{ellipsis conversion sequence}{over.ics.ellipsis}.
 \end{itemize}
 
 \pnum
@@ -2352,10 +2352,10 @@ Each conversion in \tref{over.ics.scs}
 also has an associated rank (Exact
 Match, Promotion, or Conversion).
 These are used
-to rank standard conversion sequences\iref{over.ics.rank}.
+to \link{rank standard conversion sequences}{over.ics.rank}.
 The rank of a conversion sequence is determined by considering the
-rank of each conversion in the sequence and the rank of any reference
-binding\iref{over.ics.ref}.
+rank of each conversion in the sequence and the rank of any \link{reference
+binding}{over.ics.ref}.
 If any of those has Conversion rank, the
 sequence has Conversion rank; otherwise, if any of those has Promotion rank,
 the sequence has Promotion rank; otherwise, the sequence has Exact
@@ -2392,7 +2392,7 @@ by a constructor\iref{class.conv.ctor}, the initial standard
 conversion sequence converts the source type to the type of the
 first parameter of that constructor.
 If the user-defined
-conversion is specified by a conversion function\iref{class.conv.fct}, the
+conversion is specified by a \link{conversion function}{class.conv.fct}, the
 initial standard conversion sequence
 converts the source type to the type of the
 object parameter of that conversion function.
@@ -2528,7 +2528,7 @@ the prohibition on binding a non-\keyword{const} lvalue reference to a bit-field
 \rSec4[over.ics.list]{List-initialization sequence}
 
 \pnum
-When an argument is an initializer list\iref{dcl.init.list}, it is not an
+When an argument is an initializer list\iref{dcl.init.list}, it is not an % todo
 expression and special rules apply for converting it to a parameter type.
 
 \pnum
@@ -2770,13 +2770,13 @@ When comparing the basic forms of implicit conversion sequences
 (as defined in~\ref{over.best.ics})
 \begin{itemize}
 \item
-a standard conversion sequence\iref{over.ics.scs} is a better
+a \link{standard conversion sequence}{over.ics.scs} is a better
 conversion sequence than a user-defined conversion sequence
 or an ellipsis conversion sequence, and
 \item
-a user-defined conversion sequence\iref{over.ics.user} is a
-better conversion sequence than an ellipsis conversion
-sequence\iref{over.ics.ellipsis}.
+a \link{user-defined conversion sequence}{over.ics.user} is a
+better conversion sequence than an \link{ellipsis conversion
+sequence}{over.ics.ellipsis}.
 \end{itemize}
 
 \pnum
@@ -3203,7 +3203,7 @@ the left side of an assignment\iref{expr.assign},
 \item
 a parameter of a function\iref{expr.call},
 \item
-a parameter of a user-defined operator\iref{over.oper},
+a parameter of a \link{user-defined operator}{over.oper},
 \item
 the return value of a function, operator function, or conversion\iref{stmt.return},
 \item
@@ -3407,8 +3407,8 @@ The operators
 and
 \tcode{[]}
 are formed from more than one token.
-The latter two operators are function call\iref{expr.call}
-and subscripting\iref{expr.sub}.
+The latter two operators are \link{function call}{expr.call}
+and \link{subscripting}{expr.sub}.
 \end{note}
 \indextext{operator!subscripting}%
 \indextext{operator!function call}%
@@ -3504,7 +3504,7 @@ this is not required by operator functions.
 
 \pnum
 \indextext{argument!overloaded operator and default}%
-An operator function cannot have default arguments\iref{dcl.fct.default},
+An operator function cannot have \link{default arguments}{dcl.fct.default},
 except where explicitly stated below.
 Operator
 functions cannot have more or fewer parameters than the
@@ -3949,7 +3949,7 @@ to not be included in the set of candidate functions.
 In this subclause, the term
 \defn{promoted integral type}
 is used to refer to those cv-unqualified integral types which are preserved by
-integral promotion\iref{conv.prom} (including e.g.,
+\link{integral promotion}{conv.prom} (including e.g.,
 \tcode{int}
 and
 \tcode{long}
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index 39cd5e50..ba13ba06 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -552,8 +552,8 @@ are replaced with the \grammarterm{pp-number}
 \tcode{0},
 and then each preprocessing token is converted into a token.
 \begin{note}
-An alternative
-token\iref{lex.digraph} is not an identifier,
+An \link{alternative
+token}{lex.digraph} is not an identifier,
 even when its spelling consists entirely of letters and underscores.
 Therefore it is not subject to this replacement.
 \end{note}
@@ -571,8 +571,8 @@ Thus on an
 implementation where \tcode{std::numeric_limits<int>::max()} is \tcode{0x7FFF}
 and \tcode{std::numeric_limits<unsigned int>::max()} is \tcode{0xFFFF},
 the integer literal \tcode{0x8000} is signed and positive within a \tcode{\#if}
-expression even though it is unsigned in translation phase
-7\iref{lex.phases}.
+expression even though it is unsigned in \link{translation phase
+7}{lex.phases}.
 \end{note}
 This includes interpreting \grammarterm{character-literal}s
 according to the rules in \ref{lex.ccon}.
@@ -2195,7 +2195,7 @@ of the current source line is
 the line number of the current physical source line,
 i.e., it is one greater than
 the number of new-line characters read or introduced
-in translation phase 1\iref{lex.phases}
+in \link{translation phase 1}{lex.phases}
 while processing the source file to the current preprocessing token.
 
 \pnum
@@ -2558,7 +2558,7 @@ are \impldef{presence and value of \mname{STDC_ISO_10646}}.
 \indextext{__stdcpp_threads__@\mname{STDCPP_THREADS}}%
 \mname{STDCPP_THREADS}\\
 Defined, and has the value integer literal \tcode{1}, if and only if a program
-can have more than one thread of execution\iref{intro.multithread}.
+can have more than one \link{thread of execution}{intro.multithread}.
 
 \end{description}
 
diff --git a/source/statements.tex b/source/statements.tex
index 846b203c..dbcc0a09 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -224,7 +224,7 @@ Expression statements have the form
 \end{bnf}
 
 The expression is
-a discarded-value expression\iref{expr.context}.
+a \deflink{discarded-value expression}{expr.context}.
 All
 \indextext{side effects}%
 side effects from an expression statement
@@ -452,10 +452,10 @@ the value of the condition is the value of the \grammarterm{expression};
 otherwise, it is the value of the decision variable.
 The value of the condition shall be of integral type, enumeration type, or class
 type. If of class type, the
-condition is contextually implicitly converted\iref{conv} to
+condition is \deflink{contextually implicitly converted}{conv} to
 an integral or enumeration type.
-If the (possibly converted) type is subject to integral
-promotions\iref{conv.prom}, the condition is converted
+If the (possibly converted) type is subject to \link{integral
+promotions}{conv.prom}, the condition is converted
 to the promoted type.
 Any
 statement within the \keyword{switch} statement can be labeled with one or
@@ -465,7 +465,7 @@ more case labels as follows:
 \keyword{case} constant-expression \terminal{:}
 \end{ncbnf}
 where the \grammarterm{constant-expression} shall be
-a converted constant expression\iref{expr.const.const} of the
+a converted \link{constant expression}{expr.const.const} of the
 adjusted type of the switch condition. No two of the case constants in
 the same switch shall have the same value after conversion.
 
@@ -551,7 +551,7 @@ An \grammarterm{init-statement} ends with a semicolon.
 \pnum
 \indextext{scope!\idxgram{iteration-statement}}%
 The substatement in an \grammarterm{iteration-statement} implicitly defines
-a block scope\iref{basic.scope} which is entered and exited each time
+a block \link{scope}{basic.scope} which is entered and exited each time
 through the loop.
 If the substatement in an \grammarterm{iteration-statement} is
 a single statement and not a \grammarterm{compound-statement},
@@ -650,7 +650,7 @@ fails.
 \indextext{statement!\idxcode{do}}
 
 \pnum
-The expression is contextually converted to \tcode{bool}\iref{conv};
+The expression is \deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv};
 if that conversion is ill-formed, the program is ill-formed.
 
 \pnum
@@ -1028,8 +1028,8 @@ Jump statements unconditionally transfer control.
 \indextext{local variable!destruction of}%
 \indextext{scope!destructor and exit from}%
 \begin{note}
-On exit from a scope (however accomplished), objects with automatic storage
-duration\iref{basic.stc.auto} that have been constructed in that scope are destroyed
+On exit from a scope (however accomplished), objects with \link{automatic storage
+duration}{basic.stc.auto} that have been constructed in that scope are destroyed
 in the reverse order of their construction\iref{stmt.dcl}.
 For temporaries, see~\ref{class.temporary}.
 However, the program can be terminated (by calling
@@ -1098,7 +1098,7 @@ in a function that has a return type other than \cv{}~\keyword{void};
 the \tcode{return} statement initializes the
 returned reference or prvalue result object
 of the (explicit or implicit) function call
-by copy-initialization\iref{dcl.init} from the operand.
+by \deflink{copy-initialization}{dcl.init} from the operand.
 \begin{note}
 A constructor or destructor does not have a return type.
 \end{note}
@@ -1234,7 +1234,7 @@ results in undefined behavior\ubdef{stmt.return.coroutine.flow.off}.
 The \tcode{goto} statement unconditionally transfers control to the
 statement labeled by the identifier. The identifier shall be a
 \indextext{label}%
-label\iref{stmt.label} located in the current function.
+\link{label}{stmt.label} located in the current function.
 
 \rSec1[stmt.contract.assert]{Assertion statement}
 
@@ -1346,8 +1346,8 @@ lx:
 \indextext{initialization!local \tcode{static}}%
 \indextext{initialization!local \tcode{thread_local}}%
 Dynamic initialization of a block variable with
-static storage duration\iref{basic.stc.static} or
-thread storage duration\iref{basic.stc.thread} is performed
+\link{static storage duration}{basic.stc.static} or
+\link{thread storage duration}{basic.stc.thread} is performed
 the first time control passes through its declaration; such a variable is
 considered initialized upon the completion of its initialization. If the
 initialization exits by throwing an exception, the initialization is not
@@ -1390,8 +1390,8 @@ will be destroyed if and only if it was constructed.
 \pnum
 There is an ambiguity in the grammar involving
 \grammarterm{expression-statement}{s} and \grammarterm{declaration}{s}: An
-\grammarterm{expression-statement} with a function-style explicit type
-conversion\iref{expr.type.conv} as its leftmost subexpression can be
+\grammarterm{expression-statement} with a \link{function-style explicit type
+conversion}{expr.type.conv} as its leftmost subexpression can be
 indistinguishable from a \grammarterm{declaration} where the first
 \grammarterm{declarator} starts with a \tcode{(}. In those cases the
 \grammarterm{statement} is considered a \grammarterm{declaration},
diff --git a/source/strings.tex b/source/strings.tex
index bff4b1ab..87703e3e 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -5547,13 +5547,13 @@ The contents and meaning of the header \libheaderdef{cstring}
 are the same as the C standard library header \libheader{string.h}.
 
 \pnum
-The functions \tcode{strerror} and \tcode{strtok} are not required to avoid data
-races\iref{res.on.data.races}.
+The functions \tcode{strerror} and \tcode{strtok} are not required to
+\link{avoid data races}{res.on.data.races}.
 
 \pnum
 \indextext{signal-safe!\idxcode{memcpy}}%
 \indextext{signal-safe!\idxcode{memmove}}%
-The functions \tcode{memcpy} and \tcode{memmove} are signal-safe\iref{support.signal}.
+The functions \tcode{memcpy} and \tcode{memmove} are \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 Each of these functions implicitly creates objects\iref{intro.object}
 in the destination region of storage
 immediately prior to copying the sequence of characters to the destination.
@@ -5565,7 +5565,7 @@ otherwise the value of the first parameter.
 The functions
 \tcode{strchr}, \tcode{strpbrk}, \tcode{strrchr}, \tcode{strstr}, and \tcode{memchr},
 have different signatures in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \xrefc{7.26}
diff --git a/source/support.tex b/source/support.tex
index 9abc9919..65206777 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -45,22 +45,15 @@ as summarized in \tref{support.summary}.
 
 \rSec2[cstddef.syn]{Header \tcode{<cstddef>} synopsis}
 
-\indexlibraryglobal{NULL}%
-\indexlibraryglobal{offsetof}%
-\indexlibraryglobal{ptrdiff_t}%
-\indexlibraryglobal{size_t}%
-\indexlibraryglobal{max_align_t}%
-\indexlibraryglobal{nullptr_t}%
-\indexlibraryglobal{byte}%
 \begin{codeblock}
 // all freestanding
 namespace std {
-  using ptrdiff_t = @\seebelow@;
-  using size_t = @\seebelow@;
-  using max_align_t = @\seebelow@;
-  using nullptr_t = decltype(nullptr);
+  using @\libglobal{ptrdiff_t}@ = @\seebelow@;
+  using @\libglobal{size_t}@ = @\seebelow@;
+  using @\libglobal{max_align_t}@ = @\seebelow@;
+  using @\libglobal{nullptr_t}@ = decltype(nullptr);
 
-  enum class byte : unsigned char {};
+  enum class @\libglobal{byte}@ : unsigned char {};
 
   // \ref{support.types.byteops}, \tcode{byte} type operations
   template<class IntType>
@@ -82,8 +75,8 @@ namespace std {
     constexpr IntType to_integer(byte b) noexcept;
 }
 
-#define NULL @\seebelow@
-#define offsetof(P, D) @\seebelow@
+#define @\libglobal{NULL}@ @\seebelow@
+#define @\libglobal{offsetof}@(P, D) @\seebelow@
 \end{codeblock}
 
 \pnum
@@ -102,11 +95,6 @@ and as noted in
 \rSec2[cstdlib.syn]{Header \tcode{<cstdlib>} synopsis}
 
 \indexheader{cstdlib}%
-\indexlibraryglobal{EXIT_FAILURE}%
-\indexlibraryglobal{EXIT_SUCCESS}%
-\indexlibraryglobal{MB_CUR_MAX}%
-\indexlibraryglobal{NULL}%
-\indexlibraryglobal{RAND_MAX}%
 \indexlibraryglobal{_Exit}%
 \indexlibraryglobal{abort}%
 \indexlibraryglobal{abs}%
@@ -123,7 +111,6 @@ and as noted in
 \indexlibraryglobal{div_t}%
 \indexlibraryglobal{exit}%
 \indexlibraryglobal{free}%
-\indexlibraryglobal{getenv}%
 \indexlibraryglobal{labs}%
 \indexlibraryglobal{ldiv}%
 \indexlibraryglobal{ldiv_t}%
@@ -158,11 +145,11 @@ namespace std {
   using lldiv_t = @\seebelow@;                                            // freestanding
 }
 
-#define NULL @\seebelow@                                                  // freestanding
-#define EXIT_FAILURE @\seebelow@                                          // freestanding
-#define EXIT_SUCCESS @\seebelow@                                          // freestanding
-#define RAND_MAX @\seebelow@
-#define MB_CUR_MAX @\seebelow@
+#define @\libglobal{NULL}@ @\seebelow@                                                  // freestanding
+#define @\libglobal{EXIT_FAILURE}@ @\seebelow@                                          // freestanding
+#define @\libglobal{EXIT_SUCCESS}@ @\seebelow@                                          // freestanding
+#define @\libglobal{RAND_MAX}@ @\seebelow@
+#define @\libglobal{MB_CUR_MAX}@ @\seebelow@
 
 namespace std {
   // Exposition-only function type aliases
@@ -181,7 +168,7 @@ namespace std {
   [[noreturn]] void _Exit(int status) noexcept;                         // freestanding
   [[noreturn]] void quick_exit(int status) noexcept;                    // freestanding
 
-  char* getenv(const char* name);
+  char* @\libglobal{getenv}@(const char* name);
   int system(const char* string);
 
   // \ref{c.malloc}, C library memory allocation
@@ -265,7 +252,7 @@ and except as noted in
 \ref{c.math.abs}.
 \begin{note}
 Several functions have additional overloads in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \xrefc{7.24}
@@ -321,8 +308,8 @@ is required to work as specified even if unary
 is overloaded for any of the types involved.
 \end{footnote}
 The expression \tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}
-is never type-dependent\iref{temp.dep.expr} and it is
-value-dependent\iref{temp.dep.constexpr} if and only if \tcode{\placeholder{type}} is
+is never \link{type-dependent}{temp.dep.expr} and it is
+\link{value-dependent}{temp.dep.constexpr} if and only if \tcode{\placeholder{type}} is
 dependent. The result of applying the \tcode{offsetof} macro to
 a static data member or a function member is undefined.
 No operation invoked by the \tcode{offsetof} macro shall throw an exception and
@@ -1127,7 +1114,7 @@ the specialization on the unqualified type \tcode{T}.
 
 \pnum
 Non-arithmetic standard types, such as
-\tcode{complex<T>}\iref{complex}, shall not have specializations.
+\link{\tcode{complex<T>}}{complex}, shall not have specializations.
 
 \rSec3[numeric.limits.members]{\tcode{numeric_limits} members}
 
@@ -2134,7 +2121,7 @@ The program is terminated without executing destructors for objects with automat
 thread, or static storage duration and without calling functions passed to
 \tcode{atexit()}\iref{basic.start.term}.
 \indextext{signal-safe!\idxcode{_Exit}}%
-The function \tcode{_Exit} is signal-safe\iref{support.signal}.
+The function \tcode{_Exit} is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 \end{itemdescr}
 
 \indexlibraryglobal{abort}%
@@ -2154,7 +2141,7 @@ automatic, thread, or static storage
 duration and without calling functions passed to
 \tcode{atexit()}\iref{basic.start.term}.
 \indextext{signal-safe!\idxcode{abort}}%
-The function \tcode{abort} is signal-safe\iref{support.signal}.
+The function \tcode{abort} is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 \end{itemdescr}
 
 \indexlibraryglobal{atexit}%
@@ -2171,7 +2158,8 @@ The
 functions register the function pointed to by \tcode{f}
 to be called without arguments at normal program termination.
 It is unspecified whether a call to \tcode{atexit()} that does not
-happen before\iref{intro.multithread} a call to \tcode{exit()} will succeed.
+\deflinkx{happen before}{happens before}{intro.multithread}
+a call to \tcode{exit()} will succeed.
 \begin{note}
 The \tcode{atexit()} functions do not introduce a data
 race\iref{res.on.data.races}.
@@ -2265,7 +2253,8 @@ int at_quick_exit(@\exposid{atexit-handler}@* f) noexcept;
 The \tcode{at_quick_exit()} functions register the function pointed to by \tcode{f}
 to be called without arguments when \tcode{quick_exit} is called.
 It is unspecified whether a call to \tcode{at_quick_exit()} that does not
-happen before\iref{intro.multithread} all calls to \tcode{quick_exit} will succeed.
+\deflinkx{happen before}{happens before}{intro.multithread}
+all calls to \tcode{quick_exit} will succeed.
 \begin{note}
 The
 \tcode{at_quick_exit()} functions do not introduce a
@@ -2317,7 +2306,7 @@ After calling registered functions, \tcode{quick_exit} shall call \tcode{_Exit(s
 \pnum
 \remarks
 \indextext{signal-safe!\idxcode{quick_exit}}%
-The function \tcode{quick_exit} is signal-safe\iref{support.signal}
+The function \tcode{quick_exit} is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}
 when the functions registered with \tcode{at_quick_exit} are.
 \end{itemdescr}
 
@@ -2444,7 +2433,7 @@ void* operator new(std::size_t size, std::align_val_t alignment);
 \pnum
 \effects
 The
-allocation functions\iref{basic.stc.dynamic.allocation}
+\link{allocation functions}{basic.stc.dynamic.allocation}
 called by a
 \grammarterm{new-expression}\iref{expr.new}
 to allocate
@@ -2480,7 +2469,7 @@ a null pointer value, throws
 \tcode{bad_alloc}.
 \item
 Otherwise, the function calls the current
-\tcode{new_handler} function\iref{new.handler}.
+\link{\tcode{new_handler}}{new.handler} function.
 If the called function returns, the loop repeats.
 \item
 The loop terminates when an attempt to allocate the requested storage is
@@ -2702,7 +2691,7 @@ void* operator new[](std::size_t size, std::align_val_t alignment);
 \pnum
 \effects
 The
-allocation functions\iref{basic.stc.dynamic.allocation}
+\link{allocation functions}{basic.stc.dynamic.allocation}
 called by the array form of a
 \grammarterm{new-expression}\iref{expr.new}
 to allocate
@@ -3015,8 +3004,8 @@ versions of \tcode{operator delete}, the C standard library function
 introduce a data race\iref{res.on.data.races}.
 Calls to these functions that allocate or deallocate a particular unit
 of storage shall occur in a single total order, and each such deallocation call
-shall happen before\iref{intro.multithread} the next allocation (if any) in
-this order.
+shall \deflinkx{happen before}{happens before}{intro.multithread}
+the next allocation (if any) in this order.
 
 \rSec2[alloc.errors]{Storage allocation errors}
 
@@ -3387,7 +3376,8 @@ An \impldef{return value of \tcode{type_info::name()}} \ntbs{}.
 
 \pnum
 \remarks
-The message may be a null-terminated multibyte string\iref{multibyte.strings},
+The message may be a
+\deflinkx{null-terminated multibyte string}{NTMBS@\ntmbs{}}{multibyte.strings},
 suitable for conversion and display as a
 \tcode{wstring}\iref{string.classes,locale.codecvt}.
 \end{itemdescr}
@@ -3958,7 +3948,8 @@ the ordinary literal encoding\iref{lex.ccon}.
 
 \pnum
 \remarks
-The message may be a null-terminated multibyte string\iref{multibyte.strings},
+The message may be a
+\deflinkx{null-terminated multibyte string}{NTMBS@\ntmbs{}}{multibyte.strings},
 suitable for conversion and display as a
 \tcode{wstring}\iref{string.classes,locale.codecvt}.
 The return value remains valid until the exception object from which
@@ -4109,7 +4100,7 @@ The number of uncaught exceptions\iref{except.throw} in the current thread.
 \remarks
 When \tcode{uncaught_exceptions() > 0},
 throwing an exception can result in a call of the function
-\tcode{std::terminate}\iref{except.terminate}.
+\link{\tcode{std::terminate}}{except.terminate}.
 \end{itemdescr}
 
 \rSec2[propagation]{Exception propagation}
@@ -4173,8 +4164,9 @@ exception_ptr current_exception() noexcept;
 \begin{itemdescr}
 \pnum
 \returns
-An \tcode{exception_ptr} object that refers to
-the currently handled exception\iref{except.handle} or a copy of the currently
+An \tcode{exception_ptr} object that refers to the
+\deflinkx{currently handled exception}{exception handling!currently handled exception}{except.handle}
+or a copy of the currently
 handled exception, or a null \tcode{exception_ptr} object if no exception is being
 handled. The referenced object shall remain valid at least as long as there is an
 \tcode{exception_ptr} object that refers to it.
@@ -4760,7 +4752,7 @@ constexpr bool empty() const noexcept;
 \pnum
 The header \libheaderdef{compare} specifies types, objects, and functions
 for use primarily in connection with
-the three-way comparison operator\iref{expr.spaceship}.
+the \link{three-way comparison operator}{expr.spaceship}.
 
 \indexlibraryglobal{is_eq}%
 \indexlibraryglobal{is_neq}%
@@ -6354,7 +6346,7 @@ environment.
 \end{note}
 
 \pnum
-A call to the \tcode{setlocale} function\iref{c.locales}
+A call to the \libglobalref{setlocale} function
 may introduce a data race with other
 calls to the \tcode{setlocale} function or with calls to functions that are
 affected by the current C locale. The implementation shall behave as if no
diff --git a/source/templates.tex b/source/templates.tex
index e9dc7b7d..5e28e1d9 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -715,7 +715,7 @@ struct A {};
 \rSec1[temp.names]{Names of template specializations}
 
 \pnum
-A template specialization\iref{temp.spec} can be referred to by a
+A \link{template specialization}{temp.spec} can be referred to by a
 \grammarterm{template-id}:
 
 \begin{bnf}
@@ -1089,8 +1089,8 @@ in a \grammarterm{splice-specialization-specifier}
 shall match the type and form specified for the corresponding
 parameter declared by the template in its
 \grammarterm{template-parameter-list}.
-When the parameter declared by the template is a template
-parameter pack\iref{temp.variadic}, it will correspond to zero or more
+When the parameter declared by the template is a
+\deflink{template parameter pack}{temp.variadic}, it will correspond to zero or more
 \grammarterm{template-argument}{s}.
 \begin{example}
 \begin{codeblock}
@@ -1281,7 +1281,7 @@ When a \grammarterm{simple-template-id} or
 \grammarterm{splice-specialization-specifier}
 does not designate a function,
 a default \grammarterm{template-argument} is
-implicitly instantiated\iref{temp.inst}
+\link{implicitly instantiated}{temp.inst}
 when the value of that default argument is needed.
 \begin{example}
 \begin{codeblock}
@@ -1293,7 +1293,7 @@ The default argument for \tcode{U} is instantiated to form the type \tcode{S<boo
 
 \pnum
 A \grammarterm{template-argument} followed by an ellipsis is
-a pack expansion\iref{temp.variadic}.
+a \deflink{pack expansion}{temp.variadic}.
 
 \rSec2[temp.arg.type]{Type template arguments}
 
@@ -1667,8 +1667,8 @@ if, given the following rewrite to two function templates,
 the function template corresponding to \tcode{P}
 is at least as specialized as
 the function template corresponding to \tcode{A}
-according to the partial ordering rules
-for function templates\iref{temp.func.order}.
+according to the \link{partial ordering rules
+for function templates}{temp.func.order}.
 Given an invented class template \tcode{X}
 with the \grammarterm{template-head} of \tcode{A} (including default arguments
 and \grammarterm{requires-clause}, if any):
@@ -1727,7 +1727,7 @@ There are five different kinds of constraints:
 
 \pnum
 In order for a constrained template to be instantiated\iref{temp.spec},
-its associated constraints\iref{temp.constr.decl}
+its \deflink{associated constraints}{temp.constr.decl}
 shall be satisfied as described in the following subclauses.
 \begin{note}
 Forming the name of a specialization of
@@ -1735,7 +1735,7 @@ a class template,
 a variable template, or
 an alias template\iref{temp.names}
 requires the satisfaction of its constraints.
-Overload resolution\iref{over.match.viable}
+\link{Overload resolution}{over.match.viable}
 requires the satisfaction of constraints
 on functions and function templates.
 \end{note}
@@ -1792,7 +1792,7 @@ void f(int);
 
 f('a'); // OK, calls \tcode{f(int)}
 \end{codeblock}
-In the satisfaction of the associated constraints\iref{temp.constr.decl}
+In the satisfaction of the \deflink{associated constraints}{temp.constr.decl}
 of \tcode{f}, the constraint \tcode{sizeof(char) > 1} is not satisfied;
 the second operand is not checked for satisfaction.
 \end{example}
@@ -1850,9 +1850,9 @@ in the declaration of a constrained entity (and, therefore, can involve the
 unsubstituted template parameters of the constrained entity),
 called the \defn{parameter mapping}\iref{temp.constr.decl}.
 \begin{note}
-Atomic constraints are formed by constraint normalization\iref{temp.constr.normal}.
-\tcode{E} is never a logical \logop{and} expression\iref{expr.log.and}
-nor a logical \logop{or} expression\iref{expr.log.or}.
+Atomic constraints are formed by \link{constraint normalization}{temp.constr.normal}.
+\tcode{E} is never a \link{logical \logop{and} expression}{expr.log.and}
+nor a \link{logical \logop{or} expression}{expr.log.or}.
 \end{note}
 
 \pnum
@@ -1929,7 +1929,7 @@ first substituted into its expression.
 If substitution results in an invalid type or expression
 in the immediate context of the atomic constraint\iref{temp.deduct.general},
 the constraint is not satisfied.
-Otherwise, the lvalue-to-rvalue conversion\iref{conv.lval}
+Otherwise, the \link{lvalue-to-rvalue conversion}{conv.lval}
 is performed if necessary,
 and \tcode{E} shall be a constant expression of type \tcode{bool}.
 The constraint is satisfied if and only if evaluation of \tcode{E}
@@ -2091,11 +2091,11 @@ A declaration's \defn{associated constraints} are defined as follows:
 the declaration has no associated constraints.
 
 \item Otherwise, if there is a single introduced \grammarterm{constraint-expression},
-the associated constraints are the normal form\iref{temp.constr.normal}
+the associated constraints are the \deflinkx{normal form}{normal form!constraint}{temp.constr.normal}
 of that expression.
 
-\item Otherwise, the associated constraints are the normal form of a logical
-\logop{and} expression\iref{expr.log.and} whose operands are in the
+\item Otherwise, the associated constraints are the normal form of a \link{logical
+\logop{and} expression}{expr.log.and} whose operands are in the
 following order:
 \begin{itemize}
 \item
@@ -2192,7 +2192,7 @@ so it does match \#2.
 
 \pnum
 The \defnx{normal form}{normal form!constraint} of an \grammarterm{expression} \tcode{E} is
-a constraint\iref{temp.constr.constr} that is defined as follows:
+a \deflink{constraint}{temp.constr.constr} that is defined as follows:
 %
 \begin{itemize}
 \item
@@ -2201,7 +2201,7 @@ the normal form of \tcode{E}.
 
 \item
 The normal form of an expression \tcode{E1 || E2} is
-the disjunction\iref{temp.constr.op} of
+the \deflink{disjunction}{temp.constr.op} of
 the normal forms of \tcode{E1} and \tcode{E2}.
 
 \item
@@ -2449,7 +2449,7 @@ the constraint of $A$ subsumes that of $B$.
 \end{itemize}
 %
 \begin{example}
-Let $A$ and $B$ be atomic constraints\iref{temp.constr.atomic}.
+Let $A$ and $B$ be \deflinkx{atomic constraints}{constraint!atomic}{temp.constr.atomic}.
 %
 The constraint $A \land B$ subsumes $A$, but $A$ does not subsume $A \land B$.
 %
@@ -2671,7 +2671,7 @@ declares \tcode{y} and \tcode{z} to be of the same type.
 \end{example}
 
 \pnum
-If an expression $e$ is type-dependent\iref{temp.dep.expr},
+If an expression $e$ is \link{type-dependent}{temp.dep.expr},
 \tcode{decltype($e$)}
 denotes a unique dependent type. Two such \grammarterm{decltype-specifier}{s}
 refer to the same type only if their \grammarterm{expression}{s} are
@@ -3114,7 +3114,7 @@ void S<T>::g(U) { }             // error: no matching function in \tcode{S<T>}
 
 \pnum
 A local class of non-closure type shall not have member templates.
-Access control rules\iref{class.access}
+\link{Access control rules}{class.access}
 apply to member template names.
 A destructor shall not be a member
 template.
@@ -3341,7 +3341,7 @@ the \grammarterm{alignment-specifier} without the ellipsis.
 \item In a \grammarterm{capture-list}\iref{expr.prim.lambda.capture}; the pattern is
 the \grammarterm{capture} without the ellipsis.
 
-\item In a \tcode{sizeof...} expression\iref{expr.sizeof}; the pattern is an
+\item In a \link{\tcode{sizeof...} expression}{expr.sizeof}; the pattern is an
 \grammarterm{identifier}.
 
 \item In a \grammarterm{pack-index-expression};
@@ -3972,9 +3972,9 @@ primary template.
 \pnum
 A partial specialization matches a given actual template argument
 list if the template arguments of the partial specialization can be
-deduced from the actual template argument list\iref{temp.deduct},
-and the deduced template arguments satisfy the associated constraints
-of the partial specialization, if any\iref{temp.constr.decl}.
+\link{deduced}{temp.deduct} from the actual template argument list,
+and the deduced template arguments satisfy the \deflink{associated constraints}{temp.constr.decl}
+of the partial specialization, if any.
 \begin{example}
 \begin{codeblock}
 template<class T1, class T2, int I> class A             { };    // \#1
@@ -4036,14 +4036,14 @@ of the primary template.
 For two partial specializations,
 the first is \defn{more specialized} than the second if, given the following
 rewrite to two function templates, the first function template is more
-specialized than the second according to the ordering rules for function
-templates\iref{temp.func.order}:
+specialized than the second according to the \link{ordering rules for function
+templates}{temp.func.order}:
 
 \begin{itemize}
 \item
 Each of the two
 function templates has the same template parameters
-and associated constraints\iref{temp.constr.decl}
+and \deflink{associated constraints}{temp.constr.decl}
 as the corresponding partial specialization.
 \item
 Each function template
@@ -4249,8 +4249,8 @@ void h(int* p) {
 \end{example}
 
 \pnum
-Such specializations are distinct functions and do not violate the one-definition
-rule\iref{basic.def.odr}.
+Such specializations are distinct functions and do not violate the
+\link{one-definition rule}{basic.def.odr}.
 
 \pnum
 The signature of a function template
@@ -4301,7 +4301,7 @@ For example, a template type parameter can be used in the
 Two expressions involving template parameters are considered
 \defnx{equivalent}{equivalent!expressions}
 if two function definitions containing the expressions would satisfy
-the one-definition rule\iref{basic.def.odr}, except that the tokens used
+the \link{one-definition rule}{basic.def.odr}, except that the tokens used
 to name the template parameters may differ as long as a token used to
 name a template parameter in one expression is replaced by another token
 that names the same template parameter in the other expression.
@@ -4471,8 +4471,8 @@ function template
 specialization
 is selected to match a placement allocation function\iref{basic.stc.dynamic.deallocation,expr.new};
 \item
-when a friend function declaration\iref{temp.friend}, an
-explicit instantiation\iref{temp.explicit} or an explicit specialization\iref{temp.expl.spec} refers to
+when a \link{friend function declaration}{temp.friend}, an
+\link{explicit instantiation}{temp.explicit} or an \link{explicit specialization}{temp.expl.spec} refers to
 a function template specialization.
 \end{itemize}
 
@@ -4865,7 +4865,7 @@ A \grammarterm{concept-definition}
 shall inhabit a namespace scope\iref{basic.scope.namespace}.
 
 \pnum
-A concept shall not have associated constraints\iref{temp.constr.decl}.
+A concept shall not have \deflink{associated constraints}{temp.constr.decl}.
 
 \pnum
 A concept is not instantiated\iref{temp.spec}.
@@ -5445,7 +5445,7 @@ any of the expressions
 or \grammarterm{braced-init-list}{s}
 in the
 \grammarterm{expression-list}
-is type-dependent\iref{temp.dep.expr}, or
+is \link{type-dependent}{temp.dep.expr}, or
 \item
 the \grammarterm{unqualified-id}
 is a \grammarterm{template-id} in which any of the template arguments depends
@@ -5505,7 +5505,7 @@ if it is
 \item
 in the definition of a class template, a nested class of a class template,
 a member of a class template, or a member of a nested class of a class template,
-the injected-class-name\iref{class.pre} of the class template or nested class,
+the \deflink{injected-class-name}{class.pre} of the class template or nested class,
 \item
 in the definition of a primary class template
 or a member of a primary class template, the name of the
@@ -5786,7 +5786,7 @@ used without a \grammarterm{template-argument-list}.
 \end{footnote}
 \item a \grammarterm{pack-index-specifier},
 \item denoted by \tcode{decltype(}\grammarterm{expression}{}\tcode{)},
-where \grammarterm{expression} is type-dependent\iref{temp.dep.expr}, or
+where \grammarterm{expression} is \link{type-dependent}{temp.dep.expr}, or
 \item denoted by a \grammarterm{splice-type-specifier} in which either
 the \grammarterm{splice-specifier} or
 \grammarterm{splice-specialization-specifier}
@@ -5939,7 +5939,7 @@ see~\ref{support.types}.
 \end{note}
 
 \pnum
-A class member access expression\iref{expr.ref} is
+A \link{class member access expression}{expr.ref} is
 type-dependent if
 \begin{itemize}
 \item
@@ -6321,7 +6321,7 @@ within a translation unit.
 A specialization for any template may have points of instantiation in multiple
 translation units.
 If two different points of instantiation give a template specialization
-different meanings according to the one-definition rule\iref{basic.def.odr},
+different meanings according to the \link{one-definition rule}{basic.def.odr},
 the program is ill-formed, no diagnostic required\ifndrdef{temp.point.diff.pt.diff.meaning}.
 
 \pnum
@@ -6632,7 +6632,7 @@ of type
 
 \pnum
 If a function declaration acquired its function type through
-a dependent type\iref{temp.dep.type} without using the syntactic form of
+a \link{dependent type}{temp.dep.type} without using the syntactic form of
 a function declarator, the program is ill-formed.
 \begin{example}
 \begin{codeblock}
@@ -6890,7 +6890,7 @@ decltype(+X2<int>::arr) r2; // OK, type of \tcode{arr} is complete and \tcode{ar
 \end{example}
 
 \pnum
-If the function selected by overload resolution\iref{over.match}
+If the function selected by \link{overload resolution}{over.match}
 can be determined without instantiating a class template definition,
 it is unspecified whether that instantiation actually takes place.
 \begin{example}
@@ -7247,7 +7247,7 @@ If an entity is the subject of both an explicit instantiation declaration
 and an explicit instantiation definition in the same translation unit, the
 definition shall follow the declaration. An entity that is the subject of an
 explicit instantiation declaration and that is also used
-in a way that would otherwise cause an implicit instantiation\iref{temp.inst}
+in a way that would otherwise cause an \link{implicit instantiation}{temp.inst}
 in the translation unit
 shall be the subject of an explicit instantiation definition somewhere in the
 program; otherwise the program is ill-formed, no diagnostic required\ifndrdef{temp.explicit.decl.implicit.inst}.
@@ -8332,7 +8332,7 @@ a type not permitted for such\iref{expr.prim.lambda.closure}.
 In the following example,
 assuming a \tcode{signed char}
 cannot represent the value 1000,
-a narrowing conversion\iref{dcl.init.list}
+a \deflinkx{narrowing conversion}{conversion!narrowing}{dcl.init.list}
 would be required
 to convert the \grammarterm{template-argument}
 of type \tcode{int} to \tcode{signed char},
@@ -8440,8 +8440,8 @@ is not a reference type:
 \item
 If
 \tcode{A}
-is an array type, the pointer type produced by the array-to-pointer
-standard conversion\iref{conv.array} is used in place of
+is an array type, the pointer type produced by the \link{array-to-pointer
+standard conversion}{conv.array} is used in place of
 \tcode{A}
 for type deduction;
 otherwise,
@@ -8449,7 +8449,7 @@ otherwise,
 If
 \tcode{A}
 is a function type, the pointer type produced by the
-function-to-pointer standard conversion\iref{conv.func} is used in place
+\link{function-to-pointer standard conversion}{conv.func} is used in place
 of
 \tcode{A}
 for type
@@ -8545,8 +8545,8 @@ The transformed \tcode{A}
 can be another pointer or pointer-to-member type that can be converted
 to the deduced
 \tcode{A}
-via a function pointer conversion\iref{conv.fctptr} and/or
-qualification conversion\iref{conv.qual}.
+via a \link{function pointer conversion}{conv.fctptr} and/or
+\link{qualification conversion}{conv.qual}.
 
 \item
 If
@@ -8679,7 +8679,7 @@ void test() {
 
 \pnum
 Template arguments can be deduced from the type specified when taking
-the address of an overload set\iref{over.over}.
+the address of an \link{overload set}{over.over}.
 If there is a target,
 the function template's function type and the target type
 are used as the types of
@@ -8726,7 +8726,7 @@ is not a reference type:
 If
 \tcode{P}
 is an array type, the pointer type produced by the
-array-to-pointer standard conversion\iref{conv.array} is used in place of
+\link{array-to-pointer standard conversion}{conv.array} is used in place of
 \tcode{P}
 for type
 deduction; otherwise,
@@ -8734,7 +8734,7 @@ deduction; otherwise,
 If
 \tcode{P}
 is a function type, the pointer type produced by the
-function-to-pointer standard conversion\iref{conv.func} is used in place of
+\link{function-to-pointer standard conversion}{conv.func} is used in place of
 \tcode{P}
 for
 type deduction; otherwise,
@@ -8825,7 +8825,7 @@ after a function has been selected.
 In the context of a call to a conversion function, the return types of
 the conversion function templates are used.
 \item
-In other contexts\iref{temp.func.order} the function template's function
+In \link{other contexts}{temp.func.order} the function template's function
 type is used.
 \end{itemize}
 
@@ -9339,7 +9339,7 @@ of $\texttt{P}_i$ is compared with each remaining argument in the
 template argument list of \tcode{A}. Each comparison deduces
 template arguments for subsequent positions in the template parameter
 packs expanded by $\texttt{P}_i$.
-During partial ordering\iref{temp.deduct.partial}, if $\texttt{A}_i$ was
+During \link{partial ordering}{temp.deduct.partial}, if $\texttt{A}_i$ was
 originally a pack expansion:
 \begin{itemize}
 \item if \tcode{P} does not contain a template argument corresponding to
@@ -9402,7 +9402,7 @@ each remaining parameter type in the parameter-type-list
 of \tcode{A}. Each comparison deduces template arguments for
 subsequent positions in the template parameter packs expanded by the
 function parameter pack.
-During partial ordering\iref{temp.deduct.partial}, if $\texttt{A}_i$ was
+During \link{partial ordering}{temp.deduct.partial}, if $\texttt{A}_i$ was
 originally a function parameter pack:
 \begin{itemize}
 \item if \tcode{P} does not contain a function parameter type corresponding to
@@ -9740,8 +9740,8 @@ int fv = f(g);                  // OK; \tcode{Types} contains \tcode{int}, \tcod
 In a declaration whose \grammarterm{declarator-id} refers to a specialization
 of a function template, template argument deduction is performed to identify
 the specialization to which the declaration refers. Specifically, this is done
-for explicit instantiations\iref{temp.explicit}, explicit specializations\iref{temp.expl.spec},
-and certain friend declarations\iref{temp.friend}. This is also done to
+for \link{explicit instantiations}{temp.explicit}, \link{explicit specializations}{temp.expl.spec},
+and certain \link{friend declarations}{temp.friend}. This is also done to
 determine whether a deallocation function template specialization matches a placement
 allocation function\iref{basic.stc.dynamic.deallocation,expr.new}.
 In all these cases, \tcode{P} is the type of the function template being considered
diff --git a/source/threads.tex b/source/threads.tex
index 14c5aa42..838d2254 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -5,7 +5,7 @@
 
 \pnum
 The following subclauses describe components to create and manage
-threads\iref{intro.multithread}, perform mutual exclusion, and communicate conditions
+\deflinkx{threads}{thread}{intro.multithread}, perform mutual exclusion, and communicate conditions
 and values
 between threads, as summarized in \tref{thread.summary}.
 
@@ -7558,7 +7558,7 @@ namespace std {
 
 \pnum
 A mutex object facilitates protection against data races and allows safe synchronization of
-data between execution agents\iref{thread.req.lockable}.
+data between \deflinkx{execution agents}{execution agent}{thread.req.lockable}.
 An execution agent \term{owns} a mutex from the time it successfully calls one of the
 lock functions until it calls unlock. Mutexes can be either recursive or non-recursive, and can
 grant simultaneous ownership to one or many execution agents. Both
@@ -7602,7 +7602,7 @@ atomic operations\iref{intro.multithread}. The lock and unlock operations on
 a single mutex appear to occur in a single total order.
 \begin{note}
 This
-can be viewed as the modification order\iref{intro.multithread} of the
+can be viewed as the \deflink{modification order}{intro.multithread} of the
 mutex.
 \end{note}
 \begin{note}
@@ -7682,7 +7682,7 @@ in the absence of contending mutex acquisitions.
 \pnum
 \sync
 If \tcode{try_lock()} returns \tcode{true}, prior \tcode{unlock()} operations
-on the same object \term{synchronize with}\iref{intro.multithread} this operation.
+on the same object \deflink{synchronize with}{intro.multithread} this operation.
 \begin{note}
 Since \tcode{lock()} does not synchronize with a failed subsequent
 \tcode{try_lock()}, the visibility rules are weak enough that little would be
@@ -7718,7 +7718,7 @@ Releases the calling thread's ownership of the mutex.
 
 \pnum
 \sync
-This operation synchronizes with\iref{intro.multithread} subsequent
+This operation \deflinkx{synchronizes with}{synchronize with}{intro.multithread} subsequent
 lock operations that obtain ownership on the same object.
 
 \pnum
@@ -8139,7 +8139,7 @@ Releases a shared lock on the mutex held by the calling thread.
 
 \pnum
 \sync
-This operation synchronizes with\iref{intro.multithread} subsequent
+This operation \deflinkx{synchronizes with}{synchronize with}{intro.multithread} subsequent
 \tcode{lock()} operations that obtain ownership on the same object.
 
 \pnum
@@ -8454,7 +8454,7 @@ namespace std {
 \pnum
 An object of type \tcode{lock_guard} controls the ownership of a lockable object
 within a scope. A \tcode{lock_guard} object maintains ownership of a lockable
-object throughout the \tcode{lock_guard} object's lifetime\iref{basic.life}.
+object throughout the \tcode{lock_guard} object's \deflink{lifetime}{basic.life}.
 The behavior of a program is undefined if the lockable object referenced by
 \exposid{pm} does not exist for the entire lifetime of the \tcode{lock_guard}
 object. The supplied \tcode{Mutex} type shall meet the \oldconcept{BasicLockable}
@@ -8527,7 +8527,7 @@ namespace std {
 \pnum
 An object of type \tcode{scoped_lock} controls the ownership of lockable objects
 within a scope. A \tcode{scoped_lock} object maintains ownership of lockable
-objects throughout the \tcode{scoped_lock} object's lifetime\iref{basic.life}.
+objects throughout the \tcode{scoped_lock} object's \deflink{lifetime}{basic.life}.
 The behavior of a program is undefined if the lockable objects referenced by
 \exposid{pm} do not exist for the entire lifetime of the \tcode{scoped_lock}
 object.
@@ -9684,7 +9684,7 @@ earlier returning execution.
 \pnum
 \sync
 For any given \tcode{once_flag}: all active executions occur in a total
-order; completion of an active execution synchronizes with\iref{intro.multithread}
+order; completion of an active execution \deflinkx{synchronizes with}{synchronize with}{intro.multithread}
 the start of the next one in this total order; and the returning execution
 synchronizes with the return from all passive executions.
 
@@ -11659,22 +11659,21 @@ the state object.
 
 \pnum
 Calls to functions that successfully set the stored result of a shared
-state synchronize
-with\iref{intro.multithread} calls to functions
+state \deflink{synchronize with}{intro.multithread} calls to functions
 successfully detecting the ready state resulting from that setting.
 The storage of the result
 (whether normal or exceptional) into the shared state
-synchronizes with\iref{intro.multithread}
+\deflinkx{synchronizes with}{synchronize with}{intro.multithread}
 the successful return from a call to a waiting function on the shared state.
 
 \pnum
 Some functions (e.g., \tcode{promise::set_value_at_thread_exit}) delay making
 the shared state ready until the calling thread exits. The destruction of
-each of that thread's objects with thread storage duration\iref{basic.stc.thread}
+each of that thread's objects with \link{thread storage duration}{basic.stc.thread}
 is sequenced before making that shared state ready.
 
 \pnum
-Access to the result of the same shared state may conflict\iref{intro.multithread}.
+Access to the result of the same shared state may \deflink{conflict}{intro.multithread}.
 \begin{note}
 This explicitly specifies that the result of the shared state is
 visible in the objects that reference this state in the sense of data race
@@ -11993,8 +11992,8 @@ The class template \tcode{future} defines a type for asynchronous return objects
 do not share their shared state with other asynchronous return objects.
 A default-constructed \tcode{future} object has no
 shared state. A \tcode{future} object with shared state can be created by
-functions on asynchronous providers\iref{futures.state} or by the move constructor
-and shares its shared state with
+functions on \deflinkx{asynchronous providers}{asynchronous provider}{futures.state}
+or by the move constructor and shares its shared state with
 the original asynchronous provider. The result (value or exception) of
 a \tcode{future} object
 can be
@@ -12304,7 +12303,7 @@ object has no shared state. A \tcode{shared_future} object with
 shared state can
 be created
 by conversion from a \tcode{future} object and shares its shared state with the
-original asynchronous provider\iref{futures.state} of the shared state.
+original \deflink{asynchronous provider}{futures.state} of the shared state.
 The result (value or exception) of a \tcode{shared_future} object
 can be set by
 calling a respective function on an
@@ -12753,7 +12752,7 @@ block until the associated thread has completed, as if joined, or else time
 out\iref{thread.thread.member};
 \item
 the associated thread completion
-synchronizes with\iref{intro.multithread}
+\deflinkx{synchronizes with}{synchronize with}{intro.multithread}
 the return from
 the first function
 that successfully detects the ready status of the shared state or
diff --git a/source/time.tex b/source/time.tex
index 981798e5..174c5a45 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -1217,7 +1217,7 @@ unless it meets all of the following conditions:
 are valid and each denotes a type\iref{temp.deduct},
 \item the expression
 \tcode{T::is_steady}
-is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand},
+is well-formed when treated as an \deflink{unevaluated operand}{expr.context},
 \item the expression
 \tcode{T::now()}
 is well-formed when treated as an unevaluated operand.
@@ -11099,7 +11099,7 @@ The expression
 \begin{codeblock}
 from_stream(declval<basic_istream<charT, traits>&>(), @$F$@, tp)
 \end{codeblock}
-is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
+is well-formed when treated as an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 \returns
@@ -11132,7 +11132,7 @@ The expression
 \begin{codeblock}
 from_stream(declval<basic_istream<charT, traits>&>(), @$F$@, tp, addressof(abbrev))
 \end{codeblock}
-is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
+is well-formed when treated as an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 \returns
@@ -11169,7 +11169,7 @@ from_stream(declval<basic_istream<charT, traits>&>(),
             declval<basic_string<charT, traits, Alloc>*>(),
             &offset)
 \end{codeblock}
-is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
+is well-formed when treated as an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 \returns
@@ -11209,7 +11209,7 @@ The expression
 from_stream(declval<basic_istream<charT, traits>&>(),
             @$F$@, tp, addressof(abbrev), &offset)
 \end{codeblock}
-is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
+is well-formed when treated as an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 \returns
diff --git a/source/utilities.tex b/source/utilities.tex
index 0c500de2..68918746 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -117,15 +117,15 @@ namespace std {
   template<class T, T...>
     struct integer_sequence;
   template<size_t... I>
-    using index_sequence = integer_sequence<size_t, I...>;
+    using @\libglobal{index_sequence}@ = integer_sequence<size_t, I...>;
 
   template<class T, T N>
     using make_integer_sequence = integer_sequence<T, @\seebelow{}@>;
   template<size_t N>
-    using make_index_sequence = make_integer_sequence<size_t, N>;
+    using @\libglobal{make_index_sequence}@ = make_integer_sequence<size_t, N>;
 
   template<class... T>
-    using index_sequence_for = make_index_sequence<sizeof...(T)>;
+    using @\libglobal{index_sequence_for}@ = make_index_sequence<sizeof...(T)>;
 
   // \ref{intseq.binding}, structured binding support
   template<class T> struct tuple_size;
@@ -349,7 +349,7 @@ of forwarding functions.
 \indextext{signal-safe!\idxcode{forward}}%
 \indextext{signal-safe!\idxcode{move}}%
 \indextext{signal-safe!\idxcode{move_if_noexcept}}%
-All functions specified in this subclause are signal-safe\iref{support.signal}.
+All functions specified in this subclause are \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 
 \indexlibraryglobal{forward}%
 \indextext{\idxcode{forward}}%
@@ -524,7 +524,7 @@ template<class T> constexpr add_const_t<T>& as_const(T& t) noexcept;
 
 \pnum
 The library provides the function template \tcode{declval} to simplify the definition of
-expressions which occur as unevaluated operands\iref{term.unevaluated.operand}.
+expressions which occur as \deflinkx{unevaluated operands}{unevaluated operand}{expr.context}.
 
 \indexlibraryglobal{declval}%
 \begin{itemdecl}
@@ -1787,7 +1787,7 @@ inline constexpr piecewise_construct_t piecewise_construct{};
 The \keyword{struct} \tcode{piecewise_construct_t} is an empty class type
 used as a unique type to disambiguate constructor and function overloading. Specifically,
 \tcode{pair} has a constructor with \tcode{piecewise_construct_t} as the
-first argument, immediately followed by two \tcode{tuple}\iref{tuple} arguments used
+first argument, immediately followed by two \link{\tcode{tuple}}{tuple} arguments used
 for piecewise construction of the elements of the \tcode{pair} object.
 
 \rSec1[tuple]{Tuples}
@@ -2438,7 +2438,7 @@ the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
 \effects
 Equivalent to the preceding constructors
 except that each element of non-reference type is constructed with
-uses-allocator construction\iref{allocator.uses.construction}.
+\deflink{uses-allocator construction}{allocator.uses.construction}.
 \end{itemdescr}
 
 \rSec3[tuple.assign]{Assignment}
@@ -3096,7 +3096,7 @@ template<class T> struct tuple_size<const T>;
 \pnum
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
-when treated as an unevaluated operand\iref{term.unevaluated.operand}, then
+when treated as an \deflink{unevaluated operand}{expr.context}, then
 each specialization of the template meets the \oldconcept{Unary\-Type\-Trait} requirements\iref{meta.rqmts}
 with a base characteristic of
 \begin{codeblock}
@@ -7329,6 +7329,7 @@ Equivalent to: \tcode{return std::visit<R>(std::forward<Visitor>(vis), (V)self);
 \rSec2[variant.monostate]{Class \tcode{monostate}}%
 \indexlibraryglobal{monostate}%
 
+\indexlibrary{\idxcode{monostate}}%
 \begin{itemdecl}
 struct monostate{};
 \end{itemdecl}
@@ -7500,7 +7501,8 @@ namespace std {
 \end{codeblock}
 
 \pnum
-Objects of type \tcode{bad_any_cast} are thrown by a failed \tcode{any_cast}\iref{any.nonmembers}.
+Objects of type \tcode{bad_any_cast} are thrown by a failed
+\libglobalref{any_cast}.
 
 \indexlibrarymember{what}{bad_any_cast}%
 \begin{itemdecl}
-- 
2.43.0


From 260ec0414a19670b3570a9419d05a71c5961c881 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 11 Nov 2018 02:48:33 +0100
Subject: [PATCH 3/9] Use cxxdraft-htmlgen macros to annotate non-C++ code and
 literal fragments.

---
 source/exceptions.tex |   4 +-
 source/lex.tex        | 204 ++++++++---------
 source/time.tex       | 518 +++++++++++++++++++++---------------------
 3 files changed, 363 insertions(+), 363 deletions(-)

diff --git a/source/exceptions.tex b/source/exceptions.tex
index be584f9d..bab8b5b0 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -135,11 +135,11 @@ does not declare a variable.
 Any exception thrown while destroying
 \tcode{t2}
 will result in executing
-\tcode{handler 2};
+\noncxxtcode{handler 2};
 any exception thrown while destroying
 \tcode{t1}
 will result in executing
-\tcode{handler 1}.
+\noncxxtcode{handler 1}.
 \end{example}
 
 \pnum
diff --git a/source/lex.tex b/source/lex.tex
index 3c9f22b7..2946bff3 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -336,43 +336,43 @@ the numerical value has no other meaning in this context.
 \ucode{000c} & \uname{form feed} & \\
 \ucode{0020} & \uname{space} & \\
 \ucode{000a} & \uname{line feed} & new-line \\
-\ucode{0021} & \uname{exclamation mark} & \tcode{!} \\
-\ucode{0022} & \uname{quotation mark} & \tcode{"} \\
-\ucode{0023} & \uname{number sign} & \tcode{\#} \\
-\ucode{0024} & \uname{dollar sign} & \tcode{\$} \\
-\ucode{0025} & \uname{percent sign} & \tcode{\%} \\
-\ucode{0026} & \uname{ampersand}  & \tcode{\&} \\
-\ucode{0027} & \uname{apostrophe} & \tcode{'} \\
-\ucode{0028} & \uname{left parenthesis} & \tcode{(} \\
-\ucode{0029} & \uname{right parenthesis} & \tcode{)} \\
-\ucode{002a} & \uname{asterisk} & \tcode{*} \\
-\ucode{002b} & \uname{plus sign} & \tcode{+} \\
-\ucode{002c} & \uname{comma} & \tcode{,} \\
-\ucode{002d} & \uname{hyphen-minus} & \tcode{-} \\
-\ucode{002e} & \uname{full stop} & \tcode{.} \\
-\ucode{002f} & \uname{solidus} & \tcode{/} \\
-\ucode{0030} .. \ucode{0039} & \uname{digit zero .. nine} & \tcode{0 1 2 3 4 5 6 7 8 9} \\
-\ucode{003a} & \uname{colon} & \tcode{:} \\
-\ucode{003b} & \uname{semicolon} & \tcode{;} \\
-\ucode{003c} & \uname{less-than sign} & \tcode{<} \\
-\ucode{003d} & \uname{equals sign} & \tcode{=} \\
-\ucode{003e} & \uname{greater-than sign} & \tcode{>} \\
-\ucode{003f} & \uname{question mark} & \tcode{?} \\
-\ucode{0040} & \uname{commercial at} & \tcode{@} \\
-\ucode{0041} .. \ucode{005a} & \uname{latin capital letter a .. z} & \tcode{A B C D E F G H I J K L M} \\
- & & \tcode{N O P Q R S T U V W X Y Z} \\
-\ucode{005b} & \uname{left square bracket} & \tcode{[} \\
-\ucode{005c} & \uname{reverse solidus} & \tcode{\textbackslash} \\
-\ucode{005d} & \uname{right square bracket} & \tcode{]} \\
-\ucode{005e} & \uname{circumflex accent} & \tcode{\caret} \\
-\ucode{005f} & \uname{low line} & \tcode{_} \\
-\ucode{0060} & \uname{grave accent} & \tcode{\`} \\
-\ucode{0061} .. \ucode{007a} & \uname{latin small letter a .. z} & \tcode{a b c d e f g h i j k l m} \\
- & & \tcode{n o p q r s t u v w x y z} \\
-\ucode{007b} & \uname{left curly bracket} & \tcode{\{} \\
-\ucode{007c} & \uname{vertical line} & \tcode{|} \\
-\ucode{007d} & \uname{right curly bracket} & \tcode{\}} \\
-\ucode{007e} & \uname{tilde} & \tcode{\textasciitilde} \\
+\ucode{0021} & \uname{exclamation mark} & \noncxxtcode{!} \\
+\ucode{0022} & \uname{quotation mark} & \noncxxtcode{"} \\
+\ucode{0023} & \uname{number sign} & \noncxxtcode{\#} \\
+\ucode{0024} & \uname{dollar sign} & \noncxxtcode{\$} \\
+\ucode{0025} & \uname{percent sign} & \noncxxtcode{\%} \\
+\ucode{0026} & \uname{ampersand}  & \noncxxtcode{\&} \\
+\ucode{0027} & \uname{apostrophe} & \noncxxtcode{'} \\
+\ucode{0028} & \uname{left parenthesis} & \noncxxtcode{(} \\
+\ucode{0029} & \uname{right parenthesis} & \noncxxtcode{)} \\
+\ucode{002a} & \uname{asterisk} & \noncxxtcode{*} \\
+\ucode{002b} & \uname{plus sign} & \noncxxtcode{+} \\
+\ucode{002c} & \uname{comma} & \noncxxtcode{,} \\
+\ucode{002d} & \uname{hyphen-minus} & \noncxxtcode{-} \\
+\ucode{002e} & \uname{full stop} & \noncxxtcode{.} \\
+\ucode{002f} & \uname{solidus} & \noncxxtcode{/} \\
+\ucode{0030} .. \ucode{0039} & \uname{digit zero .. nine} & \noncxxtcode{0 1 2 3 4 5 6 7 8 9} \\
+\ucode{003a} & \uname{colon} & \noncxxtcode{:} \\
+\ucode{003b} & \uname{semicolon} & \noncxxtcode{;} \\
+\ucode{003c} & \uname{less-than sign} & \noncxxtcode{<} \\
+\ucode{003d} & \uname{equals sign} & \noncxxtcode{=} \\
+\ucode{003e} & \uname{greater-than sign} & \noncxxtcode{>} \\
+\ucode{003f} & \uname{question mark} & \noncxxtcode{?} \\
+\ucode{0040} & \uname{commercial at} & \noncxxtcode{@} \\
+\ucode{0041} .. \ucode{005a} & \uname{latin capital letter a .. z} & \noncxxtcode{A B C D E F G H I J K L M} \\
+ & & \noncxxtcode{N O P Q R S T U V W X Y Z} \\
+\ucode{005b} & \uname{left square bracket} & \noncxxtcode{[} \\
+\ucode{005c} & \uname{reverse solidus} & \noncxxtcode{\textbackslash} \\
+\ucode{005d} & \uname{right square bracket} & \noncxxtcode{]} \\
+\ucode{005e} & \uname{circumflex accent} & \noncxxtcode{\caret} \\
+\ucode{005f} & \uname{low line} & \noncxxtcode{_} \\
+\ucode{0060} & \uname{grave accent} & \noncxxtcode{\`} \\
+\ucode{0061} .. \ucode{007a} & \uname{latin small letter a .. z} & \noncxxtcode{a b c d e f g h i j k l m} \\
+ & & \noncxxtcode{n o p q r s t u v w x y z} \\
+\ucode{007b} & \uname{left curly bracket} & \noncxxtcode{\{} \\
+\ucode{007c} & \uname{vertical line} & \noncxxtcode{|} \\
+\ucode{007d} & \uname{right curly bracket} & \noncxxtcode{\}} \\
+\ucode{007e} & \uname{tilde} & \noncxxtcode{\textasciitilde} \\
 \end{floattable}
 
 \pnum
@@ -611,7 +611,7 @@ given character:
 \item
 \indextext{literal!string!raw}%
 If the next character begins a sequence of characters that could be the prefix
-and initial double quote of a raw string literal, such as \tcode{R"}, the next preprocessing
+and initial double quote of a raw string literal, such as \literaltcode{R"}, the next preprocessing
 token shall be a raw string literal. Between the initial and final
 double quote characters of the raw string, any transformations performed in phase
 2 (line splicing) are reverted; this reversion
@@ -619,7 +619,7 @@ is applied before any \grammarterm{d-char}, \grammarterm{r-char}, or delimiting
 parenthesis is identified. The raw string literal is defined as the shortest sequence
 of characters that matches the raw-string pattern
 \begin{ncbnf}
-\opt{encoding-prefix} \terminal{R} raw-string
+\opt{encoding-prefix} \literalterminal{R} raw-string
 \end{ncbnf}
 
 \item Otherwise, if the next three characters are \tcode{<::} and the subsequent character
@@ -741,7 +741,7 @@ after certain occurrences of an \tcode{import} token
 \end{note}
 
 \pnum
-The appearance of either of the characters \tcode{'} or \tcode{\textbackslash} or of
+The appearance of either of the characters \noncxxtcode{'} or \tcode{\textbackslash} or of
 either of the character sequences \tcode{/*} or \tcode{//} in a
 \grammarterm{q-char-sequence} or an \grammarterm{h-char-sequence}
 is conditionally-supported with \impldef{meaning of \tcode{'}, \tcode{\textbackslash},
@@ -762,15 +762,15 @@ depending on the implementation.
 \begin{bnf}
 \nontermdef{pp-number}\br
     digit\br
-    \terminal{.} digit\br
+    \literalterminal{.} digit\br
     pp-number identifier-continue\br
-    pp-number \terminal{'} digit\br
-    pp-number \terminal{'} nondigit\br
-    pp-number \terminal{e} sign\br
-    pp-number \terminal{E} sign\br
-    pp-number \terminal{p} sign\br
-    pp-number \terminal{P} sign\br
-    pp-number \terminal{.}
+    pp-number \literalterminal{'} digit\br
+    pp-number \literalterminal{'} nondigit\br
+    pp-number \literalterminal{e} sign\br
+    pp-number \literalterminal{E} sign\br
+    pp-number \literalterminal{p} sign\br
+    pp-number \literalterminal{P} sign\br
+    pp-number \literalterminal{.}
 \end{bnf}
 
 \pnum
@@ -1198,19 +1198,19 @@ a literal has a type and a value category\iref{expr.prim.literal}.
 \nontermdef{binary-literal}\br
     \terminal{0b} binary-digit\br
     \terminal{0B} binary-digit\br
-    binary-literal \opt{\terminal{'}} binary-digit
+    binary-literal \opt{\literalterminal{'}} binary-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{octal-literal}\br
     \terminal{0}\br
-    octal-literal \opt{\terminal{'}} octal-digit
+    octal-literal \opt{\literalterminal{'}} octal-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{decimal-literal}\br
     nonzero-digit\br
-    decimal-literal \opt{\terminal{'}} digit
+    decimal-literal \opt{\literalterminal{'}} digit
 \end{bnf}
 
 \begin{bnf}
@@ -1241,14 +1241,14 @@ a literal has a type and a value category\iref{expr.prim.literal}.
 \begin{bnf}
 \nontermdef{hexadecimal-digit-sequence}\br
     hexadecimal-digit\br
-    hexadecimal-digit-sequence \opt{\terminal{'}} hexadecimal-digit
+    hexadecimal-digit-sequence \opt{\literalterminal{'}} hexadecimal-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-digit} \textnormal{one of}\br
-    \terminal{0  1  2  3  4  5  6  7  8  9}\br
-    \terminal{a  b  c  d  e  f}\br
-    \terminal{A  B  C  D  E  F}
+    \literalterminal{0  1  2  3  4  5  6  7  8  9}\br
+    \literalterminal{a  b  c  d  e  f}\br
+    \literalterminal{A  B  C  D  E  F}
 \end{bnf}
 
 \begin{bnf}
@@ -1263,17 +1263,17 @@ a literal has a type and a value category\iref{expr.prim.literal}.
 
 \begin{bnf}
 \nontermdef{unsigned-suffix} \textnormal{one of}\br
-    \terminal{u  U}
+    \literalterminal{u  U}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{long-suffix} \textnormal{one of}\br
-    \terminal{l  L}
+    \literalterminal{l  L}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{long-long-suffix} \textnormal{one of}\br
-    \terminal{ll  LL}
+    \literalterminal{ll  LL}
 \end{bnf}
 
 \begin{bnf}
@@ -1312,7 +1312,7 @@ when determining the value.
 
 \pnum
 The \grammarterm{hexadecimal-digit}s
-\tcode{a} through \tcode{f} and \tcode{A} through \tcode{F}
+\literaltcode{a} through \literaltcode{f} and \literaltcode{A} through \literaltcode{F}
 have decimal values ten through fifteen.
 \begin{example}
 The number twelve can be written \tcode{12}, \tcode{014},
@@ -1356,7 +1356,7 @@ none    &
         &
         &
   \tcode{unsigned long long int}\\\hline
-\tcode{u} or \tcode{U}  &
+\literaltcode{u} or \literaltcode{U}  &
   \tcode{unsigned int}  &
   \tcode{unsigned int}\\
                               &
@@ -1365,7 +1365,7 @@ none    &
                               &
   \tcode{unsigned long long int}   &
   \tcode{unsigned long long int}\\\hline
-\tcode{l} or \tcode{L}  &
+\literaltcode{l} or \literaltcode{L}  &
   \tcode{long int}  &
   \tcode{long int}\\
                               &
@@ -1377,22 +1377,22 @@ none    &
                               &
                               &
   \tcode{unsigned long long int}\\\hline
-Both \tcode{u} or \tcode{U}   &
+Both \literaltcode{u} or \literaltcode{U}   &
   \tcode{unsigned long int}  &
   \tcode{unsigned long int}\\
-and \tcode{l} or \tcode{L}  &
+and \literaltcode{l} or \literaltcode{L}  &
   \tcode{unsigned long long int}  &
   \tcode{unsigned long long int}\\\hline
-\tcode{ll} or \tcode{LL}  &
+\literaltcode{ll} or \literaltcode{LL}  &
   \tcode{long long int}       &
   \tcode{long long int}\\
                               &
                               &
   \tcode{unsigned long long int}\\\hline
-Both \tcode{u} or \tcode{U}   &
+Both \literaltcode{u} or \literaltcode{U}   &
   \tcode{unsigned long long int}  &
   \tcode{unsigned long long int}\\
-and \tcode{ll} or \tcode{LL}  &
+and \literaltcode{ll} or \literaltcode{LL}  &
                               &
                               \\\hline
 \tcode{z} or \tcode{Z}                  &
@@ -1440,12 +1440,12 @@ is ill-formed if it cannot be represented by \tcode{std::size_t}.
 \indextext{literal!character}%
 \begin{bnf}
 \nontermdef{character-literal}\br
-    \opt{encoding-prefix} \terminal{'} c-char-sequence \terminal{'}
+    \opt{encoding-prefix} \literalterminal{'} c-char-sequence \literalterminal{'}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{encoding-prefix} \textnormal{one of}\br
-    \terminal{u8}\quad\terminal{u}\quad\terminal{U}\quad\terminal{L}
+    \literalterminal{u8}\quad\literalterminal{u}\quad\literalterminal{U}\quad\literalterminal{L}
 \end{bnf}
 
 \begin{bnf}
@@ -1475,12 +1475,12 @@ is ill-formed if it cannot be represented by \tcode{std::size_t}.
 
 \begin{bnf}
 \nontermdef{simple-escape-sequence}\br
-    \terminal{\textbackslash} simple-escape-sequence-char
+    \literalterminal{\textbackslash} simple-escape-sequence-char
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{simple-escape-sequence-char} \textnormal{one of}\br
-    \terminal{'  "  ?  \textbackslash{} a  b  f  n  r  t  v}
+    \literalterminal{'  "  ?  \textbackslash{} a  b  f  n  r  t  v}
 \end{bnf}
 
 \begin{bnf}
@@ -1496,21 +1496,21 @@ is ill-formed if it cannot be represented by \tcode{std::size_t}.
 
 \begin{bnf}
 \nontermdef{octal-escape-sequence}\br
-    \terminal{\textbackslash} octal-digit\br
-    \terminal{\textbackslash} octal-digit octal-digit\br
-    \terminal{\textbackslash} octal-digit octal-digit octal-digit\br
-    \terminal{\textbackslash o\{} simple-octal-digit-sequence \terminal{\}}
+    \literalterminal{\textbackslash} octal-digit\br
+    \literalterminal{\textbackslash} octal-digit octal-digit\br
+    \literalterminal{\textbackslash} octal-digit octal-digit octal-digit\br
+    \literalterminal{\textbackslash o\{} simple-octal-digit-sequence \literalterminal{\}}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-escape-sequence}\br
-    \terminal{\textbackslash x} simple-hexadecimal-digit-sequence\br
-    \terminal{\textbackslash x\{} simple-hexadecimal-digit-sequence \terminal{\}}
+    \literalterminal{\textbackslash x} simple-hexadecimal-digit-sequence\br
+    \literalterminal{\textbackslash x\{} simple-hexadecimal-digit-sequence \literalterminal{\}}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{conditional-escape-sequence}\br
-    \terminal{\textbackslash} conditional-escape-sequence-char
+    \literalterminal{\textbackslash} conditional-escape-sequence-char
 \end{bnf}
 
 \begin{bnf}
@@ -1657,17 +1657,17 @@ is supported for compatibility with \CppXIV{} and C.
 {lll}
 \topline
 \lhdrx{2}{character} &  \rhdr{\grammarterm{simple-escape-sequence}} \\ \capsep
-\ucode{000a} & \uname{line feed}            & \tcode{\textbackslash n} \\
-\ucode{0009} & \uname{character tabulation} & \tcode{\textbackslash t} \\
-\ucode{000b} & \uname{line tabulation}      & \tcode{\textbackslash v} \\
-\ucode{0008} & \uname{backspace}            & \tcode{\textbackslash b} \\
-\ucode{000d} & \uname{carriage return}      & \tcode{\textbackslash r} \\
-\ucode{000c} & \uname{form feed}            & \tcode{\textbackslash f} \\
-\ucode{0007} & \uname{alert}                & \tcode{\textbackslash a} \\
-\ucode{005c} & \uname{reverse solidus}      & \tcode{\textbackslash\textbackslash} \\
-\ucode{003f} & \uname{question mark}        & \tcode{\textbackslash ?} \\
-\ucode{0027} & \uname{apostrophe}           & \tcode{\textbackslash '} \\
-\ucode{0022} & \uname{quotation mark}       & \tcode{\textbackslash "} \\
+\ucode{000a} & \uname{line feed}            & \literaltcode{\textbackslash n} \\
+\ucode{0009} & \uname{character tabulation} & \literaltcode{\textbackslash t} \\
+\ucode{000b} & \uname{line tabulation}      & \literaltcode{\textbackslash v} \\
+\ucode{0008} & \uname{backspace}            & \literaltcode{\textbackslash b} \\
+\ucode{000d} & \uname{carriage return}      & \literaltcode{\textbackslash r} \\
+\ucode{000c} & \uname{form feed}            & \literaltcode{\textbackslash f} \\
+\ucode{0007} & \uname{alert}                & \literaltcode{\textbackslash a} \\
+\ucode{005c} & \uname{reverse solidus}      & \literaltcode{\textbackslash\textbackslash} \\
+\ucode{003f} & \uname{question mark}        & \literaltcode{\textbackslash ?} \\
+\ucode{0027} & \uname{apostrophe}           & \literaltcode{\textbackslash '} \\
+\ucode{0022} & \uname{quotation mark}       & \literaltcode{\textbackslash "} \\
 \end{floattable}
 
 \rSec2[lex.fcon]{Floating-point literals}
@@ -1693,42 +1693,42 @@ is supported for compatibility with \CppXIV{} and C.
 
 \begin{bnf}
 \nontermdef{fractional-constant}\br
-    \opt{digit-sequence} \terminal{.} digit-sequence\br
-    digit-sequence \terminal{.}
+    \opt{digit-sequence} \literalterminal{.} digit-sequence\br
+    digit-sequence \literalterminal{.}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-fractional-constant}\br
-    \opt{hexadecimal-digit-sequence} \terminal{.} hexadecimal-digit-sequence\br
-    hexadecimal-digit-sequence \terminal{.}
+    \opt{hexadecimal-digit-sequence} \literalterminal{.} hexadecimal-digit-sequence\br
+    hexadecimal-digit-sequence \literalterminal{.}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{exponent-part}\br
-    \terminal{e} \opt{sign} digit-sequence\br
-    \terminal{E} \opt{sign} digit-sequence
+    \literalterminal{e} \opt{sign} digit-sequence\br
+    \literalterminal{E} \opt{sign} digit-sequence
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{binary-exponent-part}\br
-    \terminal{p} \opt{sign} digit-sequence\br
-    \terminal{P} \opt{sign} digit-sequence
+    \literalterminal{p} \opt{sign} digit-sequence\br
+    \literalterminal{P} \opt{sign} digit-sequence
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{sign} \textnormal{one of}\br
-    \terminal{+  -}
+    \literalterminal{+  -}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{digit-sequence}\br
     digit\br
-    digit-sequence \opt{\terminal{'}} digit
+    digit-sequence \opt{\literalterminal{'}} digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{floating-point-suffix} \textnormal{one of}\br
-    \terminal{f  l  f16  f32  f64  f128  bf16  F  L  F16  F32  F64  F128  BF16}
+    \literalterminal{f  l  f16  f32  f64  f128  bf16  F  L  F16  F32  F64  F128  BF16}
 \end{bnf}
 
 \pnum
@@ -1823,7 +1823,7 @@ std::float32_t z = 1e1000000000f32; // either greatest finite value or positive
 \begin{bnf}
 \nontermdef{string-literal}\br
     \opt{encoding-prefix} plain-string-literal\br
-    \opt{encoding-prefix} \terminal{R} raw-string
+    \opt{encoding-prefix} \literalterminal{R} raw-string
 \end{bnf}
 
 \begin{bnf}
@@ -1851,7 +1851,7 @@ std::float32_t z = 1e1000000000f32; // either greatest finite value or positive
 
 \begin{bnf}
 \nontermdef{raw-string}\br
-    \terminal{"} \opt{d-char-sequence} \terminal{(} \opt{r-char-sequence} \terminal{)} \opt{d-char-sequence} \terminal{"}
+    \literalterminal{"} \opt{d-char-sequence} \literalterminal{(} \opt{r-char-sequence} \literalterminal{)} \opt{d-char-sequence} \literalterminal{"}
 \end{bnf}
 
 \begin{bnf}
@@ -1937,7 +1937,7 @@ UTF-32 &
 
 \pnum
 \indextext{literal!string!raw}%
-A \grammarterm{string-literal} that has an \tcode{R}
+A \grammarterm{string-literal} that has an \literaltcode{R}
 \indextext{prefix!\idxcode{R}}%
 in the prefix is a \defn{raw string literal}. The
 \grammarterm{d-char-sequence} serves as a delimiter. The terminating
diff --git a/source/time.tex b/source/time.tex
index 174c5a45..3f52ae04 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2202,7 +2202,7 @@ If the parse fails to decode a valid duration,
 \tcode{is.setstate(ios_base::failbit)} is called and \tcode{d} is not modified.
 If \tcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -2794,9 +2794,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted
 from the successfully parsed timestamp
@@ -2987,9 +2987,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp
@@ -3186,9 +3186,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp prior to assigning that difference to \tcode{tp}.
@@ -3349,9 +3349,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp prior to assigning that difference to \tcode{tp}.
@@ -3456,9 +3456,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp prior to assigning that difference to \tcode{tp}.
@@ -3571,9 +3571,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -4224,9 +4224,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid day,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{d} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -4538,9 +4538,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid month,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{m} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -4882,9 +4882,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid year,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{y} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -5265,9 +5265,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid weekday,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{wd} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -5648,9 +5648,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid \tcode{month_day},
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{md} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -6328,9 +6328,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid \tcode{year_month},
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{ym} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -6792,9 +6792,9 @@ as specified in \ref{time.parse}.
 If the parse fails to decode a valid \tcode{year_month_day},
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{ymd} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -10487,23 +10487,23 @@ according to the following syntax:
 
 \begin{ncbnf}
 \fmtnontermdef{literal-char}\br
-    \textnormal{any character other than \tcode{\{}, \tcode{\}}, or \tcode{\%}}
+    \textnormal{any character other than \noncxxtcode{\{}, \noncxxtcode{\}}, or \noncxxtcode{\%}}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{conversion-spec}\br
-    \terminal{\%} \opt{modifier} type
+    \noncxxterminal{\%} \opt{modifier} type
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{modifier} \textnormal{one of}\br
-    \terminal{E O}
+    \noncxxterminal{E O}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{type} \textnormal{one of}\br
-    \terminal{a A b B c C d D e F g G h H I j m M n}\br
-    \terminal{p q Q r R S t T u U V w W x X y Y z Z \%}
+    \noncxxterminal{a A b B c C d D e F g G h H I j m M n}\br
+    \noncxxterminal{p q Q r R S t T u U V w W x X y Y z Z \%}
 \end{ncbnf}
 
 The productions
@@ -10576,11 +10576,11 @@ the result of formatting a chrono type
 does not contain time zone abbreviation
 and time zone offset information.
 If the information is available,
-the conversion specifiers \tcode{\%Z} and \tcode{\%z}
+the conversion specifiers \noncxxtcode{\%Z} and \noncxxtcode{\%z}
 will format this information (respectively).
 \begin{note}
 If the information is not available and
-a \tcode{\%Z} or \tcode{\%z}
+a \noncxxtcode{\%Z} or \noncxxtcode{\%z}
 conversion specifier appears in
 the \fmtgrammarterm{chrono-format-spec},
 an exception of type \tcode{format_error} is thrown,
@@ -10596,7 +10596,7 @@ A \tcode{duration} does not contain enough information
 to format as a \tcode{weekday}.
 \end{example}
 However, if a flag refers to a ``time of day''
-(e.g., \tcode{\%H}, \tcode{\%I}, \tcode{\%p}, etc.),
+(e.g., \noncxxtcode{\%H}, \noncxxtcode{\%I}, \noncxxtcode{\%p}, etc.),
 then a specialization of \tcode{duration} is interpreted as
 the time of day elapsed since midnight.
 
@@ -10608,57 +10608,57 @@ the time of day elapsed since midnight.
 \hline
 \lhdr{Specifier} & \rhdr{Replacement} \\ \capsep
 \endhead
-\tcode{\%a} &
+\noncxxtcode{\%a} &
 The locale's abbreviated weekday name.
 If the value does not contain a valid weekday,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%A} &
+\noncxxtcode{\%A} &
 The locale's full weekday name.
 If the value does not contain a valid weekday,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%b} &
+\noncxxtcode{\%b} &
 The locale's abbreviated month name.
 If the value does not contain a valid month,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%B} &
+\noncxxtcode{\%B} &
 The locale's full month name.
 If the value does not contain a valid month,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%c} &
+\noncxxtcode{\%c} &
 The locale's date and time representation.
-The modified command \tcode{\%Ec} produces
+The modified command \noncxxtcode{\%Ec} produces
 the locale's alternate date and time representation.
 \\ \rowsep
-\tcode{\%C} &
+\noncxxtcode{\%C} &
 The year divided by 100 using floored division.
 If the result is a single decimal digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%EC} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%EC} produces
 the locale's alternative representation of the century.
 \\ \rowsep
-\tcode{\%d} &
+\noncxxtcode{\%d} &
 The day of month as a decimal number.
 If the result is a single decimal digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%Od} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Od} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%D} &
-Equivalent to \tcode{\%m/\%d/\%y}.
+\noncxxtcode{\%D} &
+Equivalent to \noncxxtcode{\%m/\%d/\%y}.
 \\ \rowsep
-\tcode{\%e} &
+\noncxxtcode{\%e} &
 The day of month as a decimal number.
 If the result is a single decimal digit,
 it is prefixed with a space.
-The modified command \tcode{\%Oe} produces
+The modified command \noncxxtcode{\%Oe} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%F} &
-Equivalent to \tcode{\%Y-\%m-\%d}.
+\noncxxtcode{\%F} &
+Equivalent to \noncxxtcode{\%Y-\%m-\%d}.
 \\ \rowsep
 \tcode{\%g} &
 The last two decimal digits of the calendar year
@@ -10669,164 +10669,164 @@ If the result is a single digit it is prefixed by \tcode{0}.
 The calendar year as a decimal number,
 as specified in ISO 8601-1:2019 for the week calendar.
 If the result is less than four digits
-it is left-padded with \tcode{0} to four digits.
+it is left-padded with \noncxxtcode{0} to four digits.
 \\ \rowsep
-\tcode{\%h} &
-Equivalent to \tcode{\%b}.
+\noncxxtcode{\%h} &
+Equivalent to \noncxxtcode{\%b}.
 \\ \rowsep
-\tcode{\%H} &
+\noncxxtcode{\%H} &
 The hour (24-hour clock) as a decimal number.
 If the result is a single digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%OH} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OH} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%I} &
+\noncxxtcode{\%I} &
 The hour (12-hour clock) as a decimal number.
 If the result is a single digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%OI} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OI} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%j} &
+\noncxxtcode{\%j} &
 If the type being formatted is a specialization of \tcode{duration},
 the decimal number of \tcode{days} without padding.
 Otherwise,
 the day of the year as a decimal number.
-January 1 is \tcode{001}.
+January 1 is \noncxxtcode{001}.
 If the result is less than three digits,
-it is left-padded with \tcode{0} to three digits.
+it is left-padded with \noncxxtcode{0} to three digits.
 \\ \rowsep
-\tcode{\%m} &
+\noncxxtcode{\%m} &
 The month as a decimal number.
-Jan is \tcode{01}.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%Om} produces
+Jan is \noncxxtcode{01}.
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Om} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%M} &
+\noncxxtcode{\%M} &
 The minute as a decimal number.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OM} produces
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OM} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%n} &
+\noncxxtcode{\%n} &
 A new-line character.
 \\ \rowsep
-\tcode{\%p} &
+\noncxxtcode{\%p} &
 The locale's equivalent of the AM/PM designations associated with a 12-hour clock.
 \\ \rowsep
-\tcode{\%q} &
+\noncxxtcode{\%q} &
 The duration's unit suffix as specified in \ref{time.duration.io}.
 \\ \rowsep
-\tcode{\%Q} &
+\noncxxtcode{\%Q} &
 The duration's numeric value (as if extracted via \tcode{.count()}).
 \\ \rowsep
-\tcode{\%r} &
+\noncxxtcode{\%r} &
 The locale's 12-hour clock time.
 \\ \rowsep
-\tcode{\%R} &
-Equivalent to \tcode{\%H:\%M}.
+\noncxxtcode{\%R} &
+Equivalent to \noncxxtcode{\%H:\%M}.
 \\ \rowsep
-\tcode{\%S} &
+\noncxxtcode{\%S} &
 Seconds as a decimal number.
-If the number of seconds is less than \tcode{10}, the result is prefixed with \tcode{0}.
+If the number of seconds is less than \noncxxtcode{10}, the result is prefixed with \noncxxtcode{0}.
 If the precision of the input cannot be exactly represented with seconds,
 then the format is a decimal floating-point number with a fixed format
 and a precision matching that of the precision of the input
 (or to a microseconds precision if the conversion to floating-point decimal seconds
 cannot be made within 18 fractional digits).
 The character for the decimal point is localized according to the locale.
-The modified command \tcode{\%OS} produces
+The modified command \noncxxtcode{\%OS} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%t} &
+\noncxxtcode{\%t} &
 A horizontal-tab character.
 \\ \rowsep
-\tcode{\%T} &
-Equivalent to \tcode{\%H:\%M:\%S}.
+\noncxxtcode{\%T} &
+Equivalent to \noncxxtcode{\%H:\%M:\%S}.
 \\ \rowsep
-\tcode{\%u} &
-The calendar day of week as a decimal number (\tcode{1}-\tcode{7}),
+\noncxxtcode{\%u} &
+The calendar day of week as a decimal number (\noncxxtcode{1}-\noncxxtcode{7}),
 as specified in ISO 8601-1:2019,
-where Monday is \tcode{1}.
-The modified command \tcode{\%Ou} produces
+where Monday is \noncxxtcode{1}.
+The modified command \noncxxtcode{\%Ou} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%U} &
+\noncxxtcode{\%U} &
 The week number of the year as a decimal number.
-The first Sunday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OU} produces
+The first Sunday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OU} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%V} &
+\noncxxtcode{\%V} &
 The calendar week of year as a decimal number,
 as specified in ISO 8601-1:2019 for the week calendar.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OV} produces
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OV} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%w} &
-The weekday as a decimal number (\tcode{0}-\tcode{6}), where Sunday is \tcode{0}.
-The modified command \tcode{\%Ow} produces
+\noncxxtcode{\%w} &
+The weekday as a decimal number (\noncxxtcode{0}-\noncxxtcode{6}), where Sunday is \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Ow} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%W} &
+\noncxxtcode{\%W} &
 The week number of the year as a decimal number.
-The first Monday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OW} produces
+The first Monday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OW} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%x} &
+\noncxxtcode{\%x} &
 The locale's date representation.
-The modified command \tcode{\%Ex} produces
+The modified command \noncxxtcode{\%Ex} produces
 the locale's alternate date representation.
 \\ \rowsep
-\tcode{\%X} &
+\noncxxtcode{\%X} &
 The locale's time representation.
-The modified command \tcode{\%EX} produces
+The modified command \noncxxtcode{\%EX} produces
 the locale's alternate time representation.
 \\ \rowsep
-\tcode{\%y} &
+\noncxxtcode{\%y} &
 The last two decimal digits of the year,
 regardless of the sign of the year.
-If the result is a single digit, it is prefixed by \tcode{0}.
-The modified command \tcode{\%Oy} produces the locale's alternative representation.
-The modified command \tcode{\%Ey} produces the locale's alternative representation
-of offset from \tcode{\%EC} (year only).
+If the result is a single digit, it is prefixed by \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Oy} produces the locale's alternative representation.
+The modified command \noncxxtcode{\%Ey} produces the locale's alternative representation
+of offset from \noncxxtcode{\%EC} (year only).
 \begin{tailexample}
 \begin{codeblock}
 cout << format("{:%C %y}", -1976y);     // prints \tcode{-20 76}
 \end{codeblock}
 \end{tailexample}
 \\ \rowsep
-\tcode{\%Y} &
+\noncxxtcode{\%Y} &
 The year as a decimal number.
 If the result is less than four digits,
-it is left-padded with \tcode{0} to four digits.
-The modified command \tcode{\%EY} produces
+it is left-padded with \noncxxtcode{0} to four digits.
+The modified command \noncxxtcode{\%EY} produces
 the locale's alternative full year representation.
 \\ \rowsep
 \tcode{\%z} &
 The offset from UTC as specified in ISO 8601-1:2019, 5.3.4.1.
-For example \tcode{-0430} refers to 4 hours 30 minutes behind UTC\@.
-If the offset is zero, \tcode{+0000} is used.
-The modified commands \tcode{\%Ez} and  \tcode{\%Oz}
-insert a \tcode{:} between the hours and minutes: \tcode{-04:30}.
+For example \noncxxtcode{-0430} refers to 4 hours 30 minutes behind UTC\@.
+If the offset is zero, \noncxxtcode{+0000} is used.
+The modified commands \noncxxtcode{\%Ez} and  \noncxxtcode{\%Oz}
+insert a \noncxxtcode{:} between the hours and minutes: \noncxxtcode{-04:30}.
 If the offset information is not available,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%Z} &
+\noncxxtcode{\%Z} &
 The time zone abbreviation.
 If the time zone abbreviation is not available,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%\%} &
-A \tcode{\%} character.
+\noncxxtcode{\%\%} &
+A \noncxxtcode{\%} character.
 \\
 \end{LongTable}
 
@@ -10874,9 +10874,9 @@ template<class Duration, class charT>
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("UTC")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 \end{itemdescr}
 
@@ -10889,9 +10889,9 @@ template<class Duration, class charT>
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("UTC")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 If the argument represents a time during a positive leap second insertion,
 and if a seconds field is formatted,
@@ -10908,9 +10908,9 @@ template<class Duration, class charT>
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("TAI")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 The date and time formatted are equivalent to
 those formatted by a \tcode{sys_time} initialized with
@@ -10929,9 +10929,9 @@ template<class Duration, class charT>
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("GPS")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 The date and time formatted are equivalent to
 those formatted by a \tcode{sys_time} initialized with
@@ -10950,9 +10950,9 @@ template<class Duration, class charT>
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("UTC")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 The date and time formatted are equivalent to
 those formatted
@@ -10970,7 +10970,7 @@ template<class Duration, class charT>
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z}, \tcode{\%z}, or a modified version of \tcode{\%z} is used,
+If \noncxxtcode{\%Z}, \noncxxtcode{\%z}, or a modified version of \noncxxtcode{\%z} is used,
 an exception of type \tcode{format_error} is thrown.
 \end{itemdescr}
 
@@ -11011,18 +11011,18 @@ passed to \tcode{formatter::format}.
 \pnum
 \remarks
 If the \fmtgrammarterm{chrono-specs} is omitted,
-the result is equivalent to using \tcode{\%F \%T \%Z} as
+the result is equivalent to using \noncxxtcode{\%F \%T \%Z} as
 the \fmtgrammarterm{chrono-specs}.
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{*f.\exposid{abbrev_}}
 if \tcode{f.\exposid{abbrev_}} is not a null pointer value.
-If \tcode{\%Z} is used
+If \noncxxtcode{\%Z} is used
 and \tcode{f.\exposid{abbrev_}} is a null pointer value,
 an exception of type \tcode{format_error} is thrown.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 it is formatted with the value of \tcode{*f.\exposid{offset-sec}}
 if \tcode{f.\exposid{offset-sec}} is not a null pointer value.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used
 and \tcode{f.\exposid{offset-sec}} is a null pointer value,
 then an exception of type \tcode{format_error} is thrown.
 \end{itemdescr}
@@ -11226,8 +11226,8 @@ except that they have an unspecified effect
 on the value returned by subsequent calls to \tcode{basic_istream<>::gcount()}.
 Each overload takes a format string containing ordinary characters
 and flags which have special meaning.
-Each flag begins with a \tcode{\%}.
-Some flags can be modified by \tcode{E} or \tcode{O}.
+Each flag begins with a \noncxxtcode{\%}.
+Some flags can be modified by \noncxxtcode{E} or \noncxxtcode{O}.
 During parsing each flag interprets characters as parts of date and time types
 according to~\tref{time.parse.spec}.
 Some flags can be modified by a width parameter
@@ -11245,7 +11245,7 @@ the information that the format flag refers to,
 A \tcode{duration} cannot represent a \tcode{weekday}.
 \end{example}
 However, if a flag refers to a ``time of day''
-(e.g., \tcode{\%H}, \tcode{\%I}, \tcode{\%p}, etc.),
+(e.g., \noncxxtcode{\%H}, \noncxxtcode{\%I}, \noncxxtcode{\%p}, etc.),
 then a specialization of \tcode{duration} is parsed as
 the time of day elapsed since midnight.
 
@@ -11265,229 +11265,229 @@ is called on the \tcode{basic_istream}.
 \hline
 \lhdr{Flag} & \rhdr{Parsed value} \\ \capsep
 \endhead
-\tcode{\%a} &
+\noncxxtcode{\%a} &
 The locale's full or abbreviated case-insensitive weekday name.
 \\ \rowsep
-\tcode{\%A} &
-Equivalent to \tcode{\%a}.
+\noncxxtcode{\%A} &
+Equivalent to \noncxxtcode{\%a}.
 \\ \rowsep
-\tcode{\%b} &
+\noncxxtcode{\%b} &
 The locale's full or abbreviated case-insensitive month name.
 \\ \rowsep
-\tcode{\%B} &
-Equivalent to \tcode{\%b}.
+\noncxxtcode{\%B} &
+Equivalent to \noncxxtcode{\%b}.
 \\ \rowsep
-\tcode{\%c} &
+\noncxxtcode{\%c} &
 The locale's date and time representation.
-The modified command \tcode{\%Ec} interprets
+The modified command \noncxxtcode{\%Ec} interprets
 the locale's alternate date and time representation.
 \\ \rowsep
-\tcode{\%C} &
+\noncxxtcode{\%C} &
 The century as a decimal number.
-The modified command \tcode{\%\placeholder{N}C} specifies
+The modified command \noncxxtcode{\%\placeholder{N}C} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%EC} interprets
+The modified command \noncxxtcode{\%EC} interprets
 the locale's alternative representation of the century.
 \\ \rowsep
-\tcode{\%d} &
+\noncxxtcode{\%d} &
 The day of the month as a decimal number.
-The modified command \tcode{\%\placeholder{N}d} specifies
+The modified command \noncxxtcode{\%\placeholder{N}d} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%Od} interprets
+The modified command \noncxxtcode{\%Od} interprets
 the locale's alternative representation of the day of the month.
 \\ \rowsep
-\tcode{\%D} &
-Equivalent to \tcode{\%m/\%d/\%y}.
+\noncxxtcode{\%D} &
+Equivalent to \noncxxtcode{\%m/\%d/\%y}.
 \\ \rowsep
-\tcode{\%e} &
-Equivalent to \tcode{\%d} and can be modified like \tcode{\%d}.
+\noncxxtcode{\%e} &
+Equivalent to \noncxxtcode{\%d} and can be modified like \noncxxtcode{\%d}.
 \\ \rowsep
-\tcode{\%F} &
-Equivalent to \tcode{\%Y-\%m-\%d}.
-If modified with a width \tcode{\placeholder{N}},
-the width is applied to only \tcode{\%Y}.
+\noncxxtcode{\%F} &
+Equivalent to \noncxxtcode{\%Y-\%m-\%d}.
+If modified with a width \noncxxtcode{\placeholder{N}},
+the width is applied to only \noncxxtcode{\%Y}.
 \\ \rowsep
-\tcode{\%g} &
+\noncxxtcode{\%g} &
 The last two decimal digits of the calendar year,
 as specified in ISO 8601-1:2019 for the week calendar.
-The modified command \tcode{\%\placeholder{N}g} specifies
+The modified command \noncxxtcode{\%\placeholder{N}g} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%G} &
+\noncxxtcode{\%G} &
 The calendar year as a decimal number,
 as specified in ISO 8601-1:2019 for the week calendar.
-The modified command \tcode{\%\placeholder{N}G} specifies
+The modified command \noncxxtcode{\%\placeholder{N}G} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 4.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 4.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%h} &
-Equivalent to \tcode{\%b}.
+\noncxxtcode{\%h} &
+Equivalent to \noncxxtcode{\%b}.
 \\ \rowsep
-\tcode{\%H} &
+\noncxxtcode{\%H} &
 The hour (24-hour clock) as a decimal number.
-The modified command \tcode{\%\placeholder{N}H} specifies
+The modified command \noncxxtcode{\%\placeholder{N}H} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OH} interprets
+The modified command \noncxxtcode{\%OH} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%I} &
+\noncxxtcode{\%I} &
 The hour (12-hour clock) as a decimal number.
-The modified command \tcode{\%\placeholder{N}I} specifies
+The modified command \noncxxtcode{\%\placeholder{N}I} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OI}
+The modified command \noncxxtcode{\%OI}
 interprets the locale's alternative representation.
 \\ \rowsep
-\tcode{\%j} &
+\noncxxtcode{\%j} &
 If the type being parsed is a specialization of \tcode{duration},
 a decimal number of \tcode{days}.
 Otherwise,
 the day of the year as a decimal number.
-January 1 is \tcode{1}.
+January 1 is \noncxxtcode{1}.
 In either case,
-the modified command \tcode{\%\placeholder{N}j} specifies
+the modified command \noncxxtcode{\%\placeholder{N}j} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 3.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 3.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%m} &
+\noncxxtcode{\%m} &
 The month as a decimal number.
-January is \tcode{1}.
-The modified command \tcode{\%\placeholder{N}m} specifies
+January is \noncxxtcode{1}.
+The modified command \noncxxtcode{\%\placeholder{N}m} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%Om} interprets
+The modified command \noncxxtcode{\%Om} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%M} &
+\noncxxtcode{\%M} &
 The minutes as a decimal number.
-The modified command \tcode{\%\placeholder{N}M} specifies
+The modified command \noncxxtcode{\%\placeholder{N}M} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OM} interprets
+The modified command \noncxxtcode{\%OM} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%n} &
+\noncxxtcode{\%n} &
 Matches one whitespace character.
 \begin{tailnote}
-\tcode{\%n}, \tcode{\%t}, and a space
+\noncxxtcode{\%n}, \noncxxtcode{\%t}, and a space
 can be combined to match a wide range of whitespace patterns.
 For example,
 \tcode{"\%n "} matches one or more whitespace characters, and
 \tcode{"\%n\%t\%t"} matches one to three whitespace characters.
 \end{tailnote}
 \\ \rowsep
-\tcode{\%p} &
+\noncxxtcode{\%p} &
 The locale's equivalent of the AM/PM designations associated with a 12-hour clock.
 \\ \rowsep
-\tcode{\%r} &
+\noncxxtcode{\%r} &
 The locale's 12-hour clock time.
 \\ \rowsep
-\tcode{\%R} &
-Equivalent to \tcode{\%H:\%M}.
+\noncxxtcode{\%R} &
+Equivalent to \noncxxtcode{\%H:\%M}.
 \\ \rowsep
-\tcode{\%S} &
+\noncxxtcode{\%S} &
 The seconds as a decimal number.
-The modified command \tcode{\%\placeholder{N}S} specifies
+The modified command \noncxxtcode{\%\placeholder{N}S} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified,
+If \noncxxtcode{\placeholder{N}} is not specified,
 the default is 2 if the input time has a precision convertible to seconds.
 Otherwise the default width is determined by
 the decimal precision of the input
 and the field is interpreted as a \tcode{long double} in a fixed format.
 If encountered, the locale determines the decimal point character.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OS} interprets
+The modified command \noncxxtcode{\%OS} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%t} &
+\noncxxtcode{\%t} &
 Matches zero or one whitespace characters.
 \\ \rowsep
-\tcode{\%T} &
-Equivalent to \tcode{\%H:\%M:\%S}.
+\noncxxtcode{\%T} &
+Equivalent to \noncxxtcode{\%H:\%M:\%S}.
 \\ \rowsep
-\tcode{\%u} &
-The calendar day of week as a decimal number (\tcode{1}-\tcode{7}),
+\noncxxtcode{\%u} &
+The calendar day of week as a decimal number (\noncxxtcode{1}-\noncxxtcode{7}),
 as specified in ISO 8601-1:2019,
-where Monday is \tcode{1}.
-The modified command \tcode{\%\placeholder{N}u} specifies
+where Monday is \noncxxtcode{1}.
+The modified command \noncxxtcode{\%\placeholder{N}u} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is \tcode{1}.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is \noncxxtcode{1}.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%U} &
+\noncxxtcode{\%U} &
 The week number of the year as a decimal number.
-The first Sunday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-The modified command \tcode{\%\placeholder{N}U} specifies
+The first Sunday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+The modified command \noncxxtcode{\%\placeholder{N}U} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OU} interprets
+The modified command \noncxxtcode{\%OU} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%V} &
+\noncxxtcode{\%V} &
 The calendar week of year as a decimal number,
 as specified in ISO 8601-1:2019 for the week calendar.
-The modified command \tcode{\%\placeholder{N}V} specifies
+The modified command \noncxxtcode{\%\placeholder{N}V} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%w} &
-The weekday as a decimal number (\tcode{0}-\tcode{6}), where Sunday is \tcode{0}.
-The modified command \tcode{\%\placeholder{N}w} specifies
+\noncxxtcode{\%w} &
+The weekday as a decimal number (\noncxxtcode{0}-\noncxxtcode{6}), where Sunday is \noncxxtcode{0}.
+The modified command \noncxxtcode{\%\placeholder{N}w} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is \tcode{1}.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is \noncxxtcode{1}.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%Ow} interprets
+The modified command \noncxxtcode{\%Ow} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%W} &
+\noncxxtcode{\%W} &
 The week number of the year as a decimal number.
-The first Monday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-The modified command \tcode{\%\placeholder{N}W} specifies
+The first Monday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+The modified command \noncxxtcode{\%\placeholder{N}W} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OW} interprets
+The modified command \noncxxtcode{\%OW} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%x} &
+\noncxxtcode{\%x} &
 The locale's date representation.
-The modified command \tcode{\%Ex} interprets the locale's alternate date representation.
+The modified command \noncxxtcode{\%Ex} interprets the locale's alternate date representation.
 \\ \rowsep
-\tcode{\%X} &
+\noncxxtcode{\%X} &
 The locale's time representation.
-The modified command \tcode{\%EX} interprets the locale's alternate time representation.
+The modified command \noncxxtcode{\%EX} interprets the locale's alternate time representation.
 \\ \rowsep
-\tcode{\%y} &
+\noncxxtcode{\%y} &
 The last two decimal digits of the year,
 regardless of the sign of the year.
 If the century is not otherwise specified
-(e.g.,  with \tcode{\%C}),
+(e.g.,  with \noncxxtcode{\%C}),
 values in the range \crange{69}{99}
 are presumed to refer to the years 1969 to 1999,
 and values in the range \crange{00}{68}
 are presumed to refer to the years 2000 to 2068.
-The modified command \tcode{\%\placeholder{N}y} specifies
+The modified command \noncxxtcode{\%\placeholder{N}y} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified commands \tcode{\%Ey} and \tcode{\%Oy} interpret
+The modified commands \noncxxtcode{\%Ey} and \noncxxtcode{\%Oy} interpret
 the locale's alternative representation.
 \begin{tailexample}
 \begin{codeblock}
@@ -11496,27 +11496,27 @@ istringstream{"-20 76"} >> parse("%3C %y", y);  // \tcode{y == -1976y} is \tcode
 \end{codeblock}
 \end{tailexample}
 \\ \rowsep
-\tcode{\%Y} &
+\noncxxtcode{\%Y} &
 The year as a decimal number.
-The modified command \tcode{\%\placeholder{N}Y} specifies
+The modified command \noncxxtcode{\%\placeholder{N}Y} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 4.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 4.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%EY} interprets
+The modified command \noncxxtcode{\%EY} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%z} &
-The offset from UTC in the format \tcode{[+|-]hh[mm]}.
-For example \tcode{-0430} refers to 4 hours 30 minutes behind UTC,
-and \tcode{04} refers to 4 hours ahead of UTC\@.
-The modified commands \tcode{\%Ez} and \tcode{\%Oz}
-parse a \tcode{:} between the hours and minutes
+\noncxxtcode{\%z} &
+The offset from UTC in the format \noncxxtcode{[+|-]hh[mm]}.
+For example \noncxxtcode{-0430} refers to 4 hours 30 minutes behind UTC,
+and \noncxxtcode{04} refers to 4 hours ahead of UTC\@.
+The modified commands \noncxxtcode{\%Ez} and \noncxxtcode{\%Oz}
+parse a \noncxxtcode{:} between the hours and minutes
 and render leading zeroes on the hour field optional:
-\tcode{[+|-]h[h][:mm]}.
-For example \tcode{-04:30} refers to 4 hours 30 minutes behind UTC,
-and \tcode{4} refers to 4 hours ahead of UTC.
+\noncxxtcode{[+|-]h[h][:mm]}.
+For example \noncxxtcode{-04:30} refers to 4 hours 30 minutes behind UTC,
+and \noncxxtcode{4} refers to 4 hours ahead of UTC.
 \\ \rowsep
-\tcode{\%Z} &
+\noncxxtcode{\%Z} &
 The time zone abbreviation or name.
 A single word is parsed.
 This word can only contain characters
@@ -11524,8 +11524,8 @@ from the basic character set\iref{lex.charset}
 that are alphanumeric, or one of
 \tcode{'_'}, \tcode{'/'}, \tcode{'-'}, or \tcode{'+'}.
 \\ \rowsep
-\tcode{\%\%} &
-A \tcode{\%} character is extracted.
+\noncxxtcode{\%\%} &
+A \noncxxtcode{\%} character is extracted.
 \\
 \end{LongTable}
 
-- 
2.43.0


From d991ba7c996fe1cb0a59c9c154bb5199bb3bd1f5 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 31 May 2020 23:23:45 +0200
Subject: [PATCH 4/9] Remove more inappropriate paragraph breaks.

---
 source/algorithms.tex    |  4 ----
 source/basic.tex         |  3 ---
 source/classes.tex       |  8 --------
 source/compatibility.tex |  5 -----
 source/concepts.tex      | 16 ----------------
 source/containers.tex    | 11 -----------
 source/declarations.tex  | 14 --------------
 source/exceptions.tex    |  3 ---
 source/expressions.tex   | 24 ------------------------
 source/future.tex        |  8 --------
 source/iostreams.tex     | 15 ---------------
 source/iterators.tex     |  8 --------
 source/lib-intro.tex     | 17 -----------------
 source/limits.tex        |  1 -
 source/memory.tex        |  2 --
 source/meta.tex          |  2 --
 source/numerics.tex      |  8 --------
 source/overloading.tex   | 11 -----------
 source/preprocessor.tex  | 10 ----------
 source/ranges.tex        | 13 -------------
 source/statements.tex    |  1 -
 source/support.tex       |  4 ----
 source/templates.tex     | 36 ------------------------------------
 source/threads.tex       | 17 -----------------
 source/time.tex          | 19 -------------------
 source/utilities.tex     |  7 -------
 26 files changed, 267 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index 450e1200..c9bac8f9 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -8697,7 +8697,6 @@ but stronger than those for a partial ordering.
 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)}
@@ -9749,7 +9748,6 @@ Let $N = \tcode{last - first}$:
   For the parallel algorithm overloads,
   \bigoh{N \log N} swaps and \bigoh{N} applications of the predicate.
 \end{itemize}
-
 \end{itemdescr}
 
 \indexlibraryglobal{stable_partition}%
@@ -10908,7 +10906,6 @@ A random access range \range{a}{b} is a
 {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$,
@@ -13572,7 +13569,6 @@ template<class I>
 \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 19a1b025..ff8a1a07 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -312,7 +312,6 @@ int X::y = 1;                   // defines \tcode{X::y}
 enum { up, down };              // defines \tcode{up} and \tcode{down}
 namespace N { int d; }          // defines \tcode{N} and \tcode{N::d}
 X anX;                          // defines \tcode{anX}
-
 \end{codeblock}
 whereas these are just declarations:
 \begin{codeblock}
@@ -852,7 +851,6 @@ compute equivalent values\iref{expr.eq}.
 
 \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},
@@ -6287,7 +6285,6 @@ has the top-level cv-qualifier \keyword{volatile}.
 
 \pnum
 Every integer type has an \term{integer conversion rank} defined as follows:
-
 \begin{itemize}
 \item No two signed integer types
 have the same rank, even if they have
diff --git a/source/classes.tex b/source/classes.tex
index f1fc3a66..6bce9473 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -1640,7 +1640,6 @@ for each non-static data member of
 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}.
@@ -3263,7 +3262,6 @@ Consider an object \tcode{u} of a \keyword{union} type \tcode{U} having non-stat
 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;
@@ -3445,7 +3443,6 @@ A local class cannot have static data members\iref{class.static.data}.
 \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
@@ -5422,7 +5419,6 @@ initializers for direct and virtual base class subobjects and
 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
@@ -5903,7 +5899,6 @@ public:
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 \end{codeblock}
-
 \end{example}
 
 \rSec2[class.inhctor.init]{Initialization by inherited constructor}%
@@ -6560,7 +6555,6 @@ any non-static data member of \tcode{C} is of reference type or
 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
@@ -6681,7 +6675,6 @@ The \defnadj{synthesized}{three-way comparison}
 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
@@ -6781,7 +6774,6 @@ The \defn{common comparison type} \tcode{U}
 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 03244784..85d9897a 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -2694,7 +2694,6 @@ Overspecification.
 \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}
@@ -2766,7 +2765,6 @@ Clarify intentions, avoid workarounds.
 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};
@@ -3921,7 +3919,6 @@ is an \impldef{definition of \tcode{NULL}} null pointer constant in
 \pnum
 Header \libheaderref{cstring}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{strchr}
 \item \tcode{strpbrk}
@@ -3935,7 +3932,6 @@ Subclause \ref{cstring.syn} describes the changes.
 \pnum
 Header \libheaderref{cwchar}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{wcschr}
 \item \tcode{wcspbrk}
@@ -3960,7 +3956,6 @@ in addition to the names declared in
 \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 42828a4b..3e64abc8 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -150,7 +150,6 @@ already specifies exactly such an expression explicitly.
 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 @@ and let \tcode{f} be a function with no arguments and return type \tcode{FromR}
 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 @@ only if:
 
 \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 @@ only if
 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 @@ Let:
 \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 @@ object\iref{customization.point.object}. The expression
 \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 @@ template<class T>
 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 @@ template<class T>
 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 @@ If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type
 
 \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 @@ template<class T>
 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 @@ finds no disqualifying declaration (defined below).
 \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 @@ contains no key parameters.
 
 \pnum
 A \defnadj{disqualifying}{declaration} is
-
 \begin{itemize}
 \item
 a (non-template) function declaration that
@@ -1131,7 +1118,6 @@ template<class T>
 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 @@ lvalues of type \tcode{const remove_reference_t<T>}.
 \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 @@ then the requirements are that
 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 2d6290b2..d8ea438f 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -688,7 +688,6 @@ Unless otherwise specified (see~\ref{associative.reqmts.except}, \ref{unord.req.
 \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
@@ -751,7 +750,6 @@ as input iterators.
 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}.
@@ -982,7 +980,6 @@ is not allocator-aware or is a specialization of \tcode{basic_string},
 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}}
@@ -4058,14 +4055,12 @@ such that distance from
 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}
@@ -6083,7 +6078,6 @@ define class templates that meet the requirements for sequence containers.
 
 \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}@ = iterator_traits<InputIterator>::value_type;  // \expos
@@ -9385,7 +9379,6 @@ If \tcode{size() < sz},
 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);
@@ -20447,7 +20440,6 @@ For each of
 \tcode{stack},
 the library provides the following constexpr-enabled formatter specialization
 where \tcode{\placeholder{adaptor-type}} is the name of the template:
-
 \indexlibraryglobal{formatter}%
 \begin{codeblock}
 namespace std {
@@ -24710,7 +24702,6 @@ typename A::offset_policy
 \pnum
 \result
 A type \tcode{OP} such that:
-
 \begin{itemize}
 \item
 \tcode{OP} meets the accessor policy requirements,
@@ -26155,7 +26146,6 @@ for the $k^\text{th}$ extent of \tcode{src}.
 
 \pnum
 Let \tcode{SubExtents} be a specialization of \tcode{extents} such that:
-
 \begin{itemize}
 \item
 \tcode{SubExtents::rank()} equals
@@ -26167,7 +26157,6 @@ the type of \tcode{slices...[$k$]} is not a collapsing slice type,
 \tcode{SubExt\-ents::static_extent(\placeholder{MAP_RANK}(slices, $k$))}
 equals the following, where $\Sigma_k$
 denotes the type of \tcode{slices...[$k$]}:
-
   \begin{itemize}
   \item
   \tcode{Extents::static_extent($k$)}
diff --git a/source/declarations.tex b/source/declarations.tex
index 7dd1bc59..0ae48b34 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1600,7 +1600,6 @@ a partial specialization\iref{temp.spec.partial},
 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{;}
@@ -2512,7 +2511,6 @@ the \grammarterm{declarator} declares a function.
 
 \pnum
 Declarators have the syntax
-
 \begin{bnf}
 \nontermdef{declarator}\br
     ptr-declarator\br
@@ -4460,7 +4458,6 @@ In the following code,
 \tcode{g}
 will be called with the value
 \tcode{f(2)}:
-
 \begin{codeblock}
 int a = 1;
 int f(int);
@@ -5131,7 +5128,6 @@ To
 an object of type
 \tcode{T}
 means:
-
 \begin{itemize}
 \item
 If
@@ -5341,7 +5337,6 @@ is sequenced before those associated with
 the initialization of the $j^\text{th}$ element.
 \item
 Otherwise, if the destination type is a class type:
-
 \begin{itemize}
 \item
 If the initializer expression is a prvalue
@@ -6356,7 +6351,6 @@ a program that necessitates such a binding is ill-formed.
 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
@@ -6841,7 +6835,6 @@ int j { 1 };                        // initialize to 1
 int k { };                          // initialize to 0
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -7937,7 +7930,6 @@ as $\tcode{T}_i$ if the initializer is a prvalue,
 as ``lvalue reference to $\tcode{T}_i$'' if the initializer is an lvalue, or
 as ``rvalue reference to $\tcode{T}_i$'' 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}
@@ -8069,7 +8061,6 @@ struct S {
   enum E : int {};              // error: redeclaration of enumeration
 };
 \end{codeblock}
-
 \end{example}
 \end{note}
 The \grammarterm{identifier} in an \grammarterm{enum-head-name}
@@ -8165,7 +8156,6 @@ If the underlying
 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
@@ -8624,7 +8614,6 @@ void h() {
 \pnum
 A \grammarterm{namespace-alias-definition} declares a \defnadj{namespace}{alias}
 according to the following grammar:
-
 \begin{bnf}
 \nontermdef{namespace-alias}\br
         identifier
@@ -8798,7 +8787,6 @@ not declare functions or function templates, the use of the name is ill-formed\i
 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 { };
@@ -9361,7 +9349,6 @@ otherwise identical.
 \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}}%
 %
@@ -10238,7 +10225,6 @@ may be applied to a function or a lambda call operator or
 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 bab8b5b0..cfebc253 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -89,7 +89,6 @@ void f() {
     goto l2;        // OK
   }
 }
-
 \end{codeblock}
 \end{example}
 \indextext{\idxcode{goto}!and try block}%
@@ -561,12 +560,10 @@ to pointers to private or protected or ambiguous classes,
 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}
diff --git a/source/expressions.tex b/source/expressions.tex
index 343e8173..19c5f0a2 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -510,7 +510,6 @@ applied. The \link{lvalue-to-rvalue}{conv.lval} conversion is applied
 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,
@@ -554,7 +553,6 @@ Standard conversions are implicit conversions with built-in meaning.
 \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
@@ -582,7 +580,6 @@ a required destination type and value category.
 \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}.
@@ -708,7 +705,6 @@ int n = g(true);    // OK, does not access \tcode{y.n}
 \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
@@ -1227,7 +1223,6 @@ type cause conversions and yield result types in a similar way. The
 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
@@ -1270,7 +1265,6 @@ As a consequence, operands of type \keyword{bool}, \keyword{char8_t}, \keyword{c
 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.
@@ -2862,7 +2856,6 @@ auto counter = [i=0]() mutable -> decltype(i) {     // OK, returns \tcode{int}
 \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
@@ -3492,7 +3485,6 @@ The \grammarterm{expression} is an unevaluated operand.
 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)
@@ -3511,7 +3503,6 @@ $E$ shall not be a potentially-throwing expression.
 
 \item
 If the \grammarterm{return-type-requirement} is present, then:
-
 \begin{itemize}
 \item
 Substitution of template arguments (if any)
@@ -4670,7 +4661,6 @@ referred to by \tcode{T}.
 \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
@@ -5198,7 +5188,6 @@ constness.
 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
@@ -5634,7 +5623,6 @@ is called a \term{suspension context} of the function.
 \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
@@ -6017,7 +6005,6 @@ and
 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}
@@ -6377,7 +6364,6 @@ the alignment argument is removed from the argument list;
 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.
 
@@ -6455,7 +6441,6 @@ necessarily be the same as that of the block if the object is an array.
 \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}.
@@ -6734,7 +6719,6 @@ of their constructor; see~\ref{class.base.init}).
 \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
@@ -7601,7 +7585,6 @@ or one operand has integral type and
 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,
@@ -7756,7 +7739,6 @@ is considered to be equivalent to a pointer to a hypothetical array element
 $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
@@ -7769,7 +7751,6 @@ neither member is a subobject of zero size
 and their class is not a union.
 
 \item Otherwise, neither pointer is required to compare greater than the other.
-
 \end{itemize}
 
 \pnum
@@ -7839,7 +7820,6 @@ If at least one of the converted operands is a pointer,
 \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
@@ -7869,7 +7849,6 @@ qualification conversions\iref{conv.qual}
 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
@@ -8154,7 +8133,6 @@ Attempts are made to form an implicit conversion sequence
 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}'',
@@ -8233,7 +8211,6 @@ subclause.
 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 is copy-initialized using the selected operand.
@@ -8263,7 +8240,6 @@ pointer type\iref{expr.type}. The result is of the composite pointer type.
 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 c594ef17..68cdef6e 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -283,7 +283,6 @@ shown in the above synopsis.
 \pnum
 The header \libheaderrefx{type_traits}{meta.type.synop}
 has the following addition:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct is_trivial;
@@ -523,7 +522,6 @@ template<class T> bool operator>=(const T& x, const T& y);
 
 \pnum
 The header \libheaderref{tuple} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct tuple_size<volatile T>;
@@ -593,7 +591,6 @@ are included.
 
 \pnum
 The header \libheaderref{variant} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct variant_size<volatile T>;
@@ -671,7 +668,6 @@ y = b;
 
 \pnum
 The header \libheaderrefx{iterator}{iterator.synopsis} has the following addition:
-
 \indexlibraryglobal{iterator}%
 \begin{codeblock}
 namespace std {
@@ -705,7 +701,6 @@ only to callers of that class.
 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&> {
@@ -719,7 +714,6 @@ class MyIterator :
 \pnum
 The following member is declared in addition to those members
 specified in \ref{move.iter.elem}:
-
 \begin{codeblock}
 namespace std {
   template<class Iterator>
@@ -829,7 +823,6 @@ are not required to avoid data races\iref{res.on.data.races}.
 
 \pnum
 The header \libheaderrefx{filesystem}{fs.filesystem.syn} has the following additions:
-
 \indexlibraryglobal{u8path}%
 \begin{itemdecl}
 template<class Source>
@@ -949,7 +942,6 @@ std::string generic_string() const;
 
 \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 a25f980c..297a4fcb 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -2105,14 +2105,12 @@ does nothing.
 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;
 
@@ -7186,7 +7184,6 @@ clears \tcode{ios_base::skipws} in the format flags stored in the
 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
@@ -7225,7 +7222,6 @@ then the expression
 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
@@ -7271,7 +7267,6 @@ then the expression
 \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}
@@ -7314,7 +7309,6 @@ then the expression
 \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) {
@@ -7355,7 +7349,6 @@ then the expression
 \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
@@ -7401,7 +7394,6 @@ then the expression
 \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
@@ -7451,7 +7443,6 @@ An object of unspecified type such that if
 \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) {
@@ -7490,7 +7481,6 @@ An object of unspecified type such that if
 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) {
@@ -7526,7 +7516,6 @@ An object of unspecified type such that if \tcode{in} is an object of type
 \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) {
@@ -7565,7 +7554,6 @@ An object of unspecified type such that if \tcode{out} is an object of
 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) {
@@ -11393,7 +11381,6 @@ with the specialization that a sequence of characters is read from the input
 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];
 const char*  extern_end;
@@ -13884,7 +13871,6 @@ without an intervening \grammarterm{root-directory} element.
 \pnum
 \indextext{path!normalization|(}%
 \defnx{Normalization}{normalization!path|see{path, normalization}} 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}.
@@ -17026,7 +17012,6 @@ recursive_directory_iterator& increment(error_code& ec);
 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 fe0df33f..ca988324 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -963,7 +963,6 @@ may be declared as \keyword{void}.
 \pnum
 The definitions in this subclause make use of the following
 exposition-only concepts:
-
 \begin{codeblock}
 template<class I>
 concept @\defexposconcept{cpp17-iterator}@ =
@@ -1021,7 +1020,6 @@ concept @\defexposconcept{cpp17-random-access-iterator}@ =
 \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
@@ -1168,7 +1166,6 @@ The name \tcode{ranges::iter_move} denotes
 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
@@ -2811,7 +2808,6 @@ namespace std {
 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;
@@ -2829,7 +2825,6 @@ If
 \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
@@ -3416,7 +3411,6 @@ As if by:
 Iterator tmp = current;
 return *--tmp;
 \end{codeblock}
-
 \end{itemdescr}
 
 \indexlibrarymember{operator->}{reverse_iterator}%
@@ -4767,7 +4761,6 @@ vector<string> v1(s.begin(), s.end());          // copies strings into \tcode{v1
 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}}
@@ -6412,7 +6405,6 @@ partial_sum(istream_iterator<double, char>(cin),
   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/lib-intro.tex b/source/lib-intro.tex
index f7e65073..5597e57d 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -196,7 +196,6 @@ save space, items that do not apply to a Clause are omitted.
 For example, if a Clause does not specify any requirements,
 there will be no ``Requirements'' subclause.
 \end{footnote}
-
 \begin{itemize}
 \item Summary
 \item Requirements
@@ -213,7 +212,6 @@ subclause and the library entities provided in each header.
 
 \pnum
 The contents of the summary and the detailed specifications include:
-
 \begin{itemize}
 \item macros
 \item values
@@ -230,7 +228,6 @@ The contents of the summary and the detailed specifications include:
 \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
@@ -305,7 +302,6 @@ are additionally imposed on the use of the declaration.
 
 \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)
@@ -322,7 +318,6 @@ To save space, items that do not apply to a class are omitted.
 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
@@ -340,7 +335,6 @@ To save space, elements that do not apply to a function are omitted.
 For example, if a function specifies no
 preconditions, there will be no \expects element.
 \end{footnote}
-
 \begin{itemize}
 \item
 \constraints
@@ -623,7 +617,6 @@ values\iref{basic.fundamental}.
 
 \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$@ };
 
@@ -656,7 +649,6 @@ or as a
 
 \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.
@@ -733,7 +725,6 @@ The value \textit{Y} \defnx{is set}{bitmask!value!is set} in the object
 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}
@@ -979,7 +970,6 @@ some subclauses provide representative declarations, and semantic requirements,
 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}
@@ -1938,7 +1928,6 @@ An object \tcode{t} is \defn{swappable with} an object \tcode{u} if and only if
 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}.
@@ -2944,7 +2933,6 @@ for that type can fail by throwing an object of type
 \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 {
@@ -3438,13 +3426,11 @@ the description of function semantics apply
 to both the default version defined by the \Cpp{} standard library and
 the replacement function defined by the program.
 
-
 \rSec3[handler.functions]{Handler functions}
 
 \pnum
 The \Cpp{} standard library provides a default version of the following handler
 function\iref{support}:
-
 \begin{itemize}
 \item
 \tcode{terminate_handler}
@@ -3465,7 +3451,6 @@ Exception handling.
 \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}%
@@ -3491,7 +3476,6 @@ on the implementation.
 
 \pnum
 In particular, the behavior is undefined in the following cases:
-
 \begin{itemize}
 \item
 For replacement functions\iref{replacement.functions}, if the installed replacement function does not
@@ -3770,7 +3754,6 @@ functions an implementation shall provide corresponding definitions.
 \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 877f21f3..7fc0a416 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -123,5 +123,4 @@ Handlers per try block\iref{except.handle} [256].
 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/memory.tex b/source/memory.tex
index 2c68fbe7..e89f767b 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -1525,7 +1525,6 @@ when considered as an unevaluated operand.
 
 \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
@@ -4086,7 +4085,6 @@ template<class D, class A> constexpr shared_ptr(nullptr_t p, D d, A a);
 \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 836ccd95..880b68a7 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -1684,7 +1684,6 @@ The predicate condition for a template specialization \tcode{is_convertible<From
 shall be satisfied if and only if
 the return statement\iref{stmt.return} 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>();
@@ -2194,7 +2193,6 @@ If any of the types computed above is ill-formed, then
 \pnum
 For the \tcode{common_type} trait applied to a template parameter pack \tcode{T} of types,
 the member \tcode{type} shall be either declared 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 935afa2b..c79aa0d9 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -606,7 +606,6 @@ template<class T> constexpr complex<T> operator+(const complex<T>& lhs);
 \pnum
 \returns
 \tcode{complex<T>(lhs)}.
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -745,7 +744,6 @@ template<class T, class charT, class traits>
 \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());
@@ -4275,7 +4273,6 @@ template<class RandomAccessIterator>
  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,
@@ -8402,7 +8399,6 @@ A unique function with the indicated name can be applied (unqualified)
 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}
@@ -8418,7 +8414,6 @@ template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 Equivalent to \tcode{x.swap(y)}.
 \end{itemdescr}
 
-
 \rSec2[class.slice]{Class \tcode{slice}}
 
 \rSec3[class.slice.overview]{Overview}
@@ -8838,7 +8833,6 @@ namespace std {
 This template is a helper template used by the
 \tcode{gslice}
 subscript operator
-
 \indexlibraryglobal{gslice_array}%
 \indexlibraryglobal{valarray}%
 \begin{itemdecl}
@@ -8964,7 +8958,6 @@ namespace std {
 
 \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>&);
@@ -9081,7 +9074,6 @@ namespace std {
 
 \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>&);
diff --git a/source/overloading.tex b/source/overloading.tex
index 869dca71..bf8063ae 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -103,7 +103,6 @@ the list of arguments in its own unique way.
 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
@@ -396,7 +395,6 @@ Such a
 \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
@@ -1018,7 +1016,6 @@ The lookup rules for operators in expressions are different than
 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);
@@ -1081,7 +1078,6 @@ Assuming that
 \tcode{T}
 a class type,
 the candidate functions are selected as follows:
-
 \begin{itemize}
 \item
 The non-explicit constructors\iref{class.conv.ctor} of
@@ -1127,7 +1123,6 @@ conversion function to be invoked.
 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
@@ -1199,7 +1194,6 @@ list-initialized such that \ref{dcl.init.list} specifies that overload resolutio
 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,
@@ -1281,7 +1275,6 @@ called the \defn{copy deduction candidate}.
 For each \grammarterm{deduction-guide},
 a function or function template
 with the following properties:
-
 \begin{itemize}
 \item
 The \grammarterm{template-head}, if any,
@@ -2783,7 +2776,6 @@ sequence}{over.ics.ellipsis}.
 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
@@ -3015,7 +3007,6 @@ int i = f(a);                   // calls \tcode{f(int)}, because \tcode{short} $
                                 // better than \tcode{short} $\to$ \tcode{float}.
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -3024,7 +3015,6 @@ better conversion than a Promotion, which is a better conversion than
 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
@@ -4286,7 +4276,6 @@ is a \defnx{literal operator template}{literal!operator!template}.
 \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 ba13ba06..a4228a22 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -200,7 +200,6 @@ begins with the first character in the source file
 (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
@@ -646,7 +645,6 @@ including within a preprocessing directive.
 \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>
@@ -808,14 +806,12 @@ However, using the \tcode{< >} form for headers provided
 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
@@ -823,7 +819,6 @@ achieves wider portability. For instance:
 This illustrates macro-replaced
 \tcode{\#include}
 directives:
-
 \begin{codeblock}
 #if VERSION == 1
     #define INCFILE  "vers1.h"
@@ -2044,7 +2039,6 @@ is optional.
 \pnum
 \begin{example}
 In the following fragment:
-
 \begin{codeblock}
 #define hash_hash # ## #
 #define mkstr(a) # a
@@ -2054,7 +2048,6 @@ char p[] = join(x, y);          // equivalent to \tcode{char p[] = "x \#\# y";}
 \end{codeblock}
 
 The expansion produces, at various stages:
-
 \begin{codeblock}
 join(x, y)
 in_between(x hash_hash y)
@@ -2290,7 +2283,6 @@ has no effect.
 
 \pnum
 The following macro names shall be defined by the implementation:
-
 \begin{description}
 
 \item
@@ -2484,7 +2476,6 @@ an \impldef{text of \mname{TIME} when time of translation is not available} vali
 
 \pnum
 The following macro names are conditionally defined by the implementation:
-
 \begin{description}
 \item
 \indextext{__stdcpp_float16_t__@\mname{STDCPP_FLOAT16_T}}%
@@ -2559,7 +2550,6 @@ are \impldef{presence and value of \mname{STDC_ISO_10646}}.
 \mname{STDCPP_THREADS}\\
 Defined, and has the value integer literal \tcode{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 6a066e87..6305fe97 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -657,7 +657,6 @@ object\iref{customization.point.object}.
 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
@@ -718,7 +717,6 @@ object\iref{customization.point.object}.
 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
@@ -844,7 +842,6 @@ object\iref{customization.point.object}.
 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
@@ -908,7 +905,6 @@ object\iref{customization.point.object}.
 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
@@ -1033,7 +1029,6 @@ object\iref{customization.point.object}.
 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},
@@ -1163,7 +1158,6 @@ object\iref{customization.point.object}.
 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},
@@ -1214,7 +1208,6 @@ object\iref{customization.point.object}.
 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
@@ -1755,7 +1748,6 @@ manipulating ranges.
 \pnum
 Many of the types in \ref{range.utility} are specified in terms of
 the following exposition-only concepts:
-
 \begin{codeblock}
 template<class R>
   concept @\defexposconceptnc{simple-view}@ =                                     // \expos
@@ -5858,7 +5850,6 @@ If \tcode{decltype((F))} does not model
 \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
@@ -5884,7 +5875,6 @@ then
 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>};
@@ -6346,7 +6336,6 @@ If \tcode{decltype((F))} does not model
 \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
@@ -7385,7 +7374,6 @@ if and only if \exposid{ref-is-glvalue} is \tcode{true}, and
 \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
@@ -9616,7 +9604,6 @@ appears in the immediate context of a template instantiation.
 \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/statements.tex b/source/statements.tex
index dbcc0a09..23c63b09 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -731,7 +731,6 @@ exposition only; and
 
 \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
diff --git a/source/support.tex b/source/support.tex
index 65206777..0a30bcb5 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -2452,7 +2452,6 @@ This requirement is binding on any replacement versions of these functions.
 
 \pnum
 \default
-
 \begin{itemize}
 \item
 Executes a loop:
@@ -2931,7 +2930,6 @@ Intentionally performs no other action.
 \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();
@@ -4834,7 +4832,6 @@ are collectively termed the \defn{comparison category types}.
 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 @\exposidnc{ord}@ { @\exposidnc{equal}@ = 0, @\exposidnc{equivalent}@ = @\exposidnc{equal}@, @\exposidnc{less}@ = -1, @\exposidnc{greater}@ = 1 }; // \expos
 enum class @\exposidnc{ncmp}@ { @\exposidnc{unordered}@ = -127 };                                     // \expos
@@ -5792,7 +5789,6 @@ if the \grammarterm{qualified-id} \tcode{R::promise_type} is valid and
 denotes a type\iref{temp.deduct},
 then \tcode{coroutine_traits<R, ArgTypes...>} has the following publicly
 accessible member:
-
 \begin{codeblock}
 using promise_type = R::promise_type;
 \end{codeblock}
diff --git a/source/templates.tex b/source/templates.tex
index 5e28e1d9..f77dba61 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -256,7 +256,6 @@ in some translation unit; no diagnostic is required\ifndrdef{temp.pre.reach.def}
 The syntax for
 \grammarterm{template-parameter}{s}
 is:
-
 \begin{bnf}
 \nontermdef{template-parameter}\br
   type-parameter\br
@@ -1672,7 +1671,6 @@ for function templates}{temp.func.order}.
 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
@@ -2069,7 +2067,6 @@ or templated function declaration\iref{dcl.fct}
 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
@@ -2085,7 +2082,6 @@ that are used to constrain the declaration.
 \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.
@@ -2892,7 +2888,6 @@ public:
 
 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");
@@ -3284,7 +3279,6 @@ produces zero or more instantiations of the pattern in a list (described below).
 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.
@@ -3898,7 +3892,6 @@ All other constant template arguments are specialized.
 \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 constant template
@@ -3912,7 +3905,6 @@ template< int X, int (*array_ptr)[X] > class A {};
 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
@@ -4038,7 +4030,6 @@ the first is \defn{more specialized} than the second if, given the following
 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
@@ -4190,7 +4181,6 @@ A<char>::B<int>  abci;                                          // uses \#1
 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>&);
@@ -4245,7 +4235,6 @@ void h(int* p) {
 }
 \end{codeblock}
 \end{minipage}
-
 \end{example}
 
 \pnum
@@ -4431,7 +4420,6 @@ to guarantee that functionally equivalent declarations will be treated
 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>);
@@ -4522,7 +4510,6 @@ then the order of the function parameters in its transformed template
 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$''
@@ -4780,7 +4767,6 @@ template<template<class,class> class TT>
   void g(TT<int, Alloc<int>>);
 g(v);               // OK, \tcode{TT} = \tcode{vector}
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -5646,7 +5632,6 @@ of a class that is the current instantiation.
 
 \pnum
 A qualified name\iref{basic.lookup.qual} is dependent if
-
 \begin{itemize}
 \item
 it is a \grammarterm{conversion-function-id}
@@ -5898,7 +5883,6 @@ specified by the
 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
@@ -5916,7 +5900,6 @@ typename-specifier braced-init-list\br
 \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
@@ -6028,7 +6011,6 @@ is type-dependent or the
 \grammarterm{type-id}
 or \grammarterm{nofun-type-id}
 is dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} unary-expression\br
 \keyword{sizeof} \terminal{(} nofun-type-id \terminal{)}\br
@@ -6057,7 +6039,6 @@ any \grammarterm{expression} in the \grammarterm{expression-list}
 is value-dependent or
 any \grammarterm{assignment-expression} in the \grammarterm{braced-init-list}
 is value-dependent:
-
 \begin{ncsimplebnf}
 simple-type-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
 typename-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
@@ -6072,7 +6053,6 @@ typename-specifier braced-init-list\br
 
 \pnum
 Expressions of the following form are value-dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} \terminal{...} \terminal{(} identifier \terminal{)}\br
 fold-expression
@@ -7100,7 +7080,6 @@ template.
 
 \pnum
 The syntax for explicit instantiation is:
-
 \begin{bnf}
 \nontermdef{explicit-instantiation}\br
   \opt{\keyword{extern}} \keyword{template} declaration
@@ -7575,7 +7554,6 @@ otherwise, it is a declaration.
 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
@@ -7834,7 +7812,6 @@ An empty template argument list can be used to indicate that a given
 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
@@ -8435,7 +8412,6 @@ void h(int x, float& y) {
 If
 \tcode{P}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -8530,7 +8506,6 @@ the type
 is transformed as described above).
 However, there are
 three cases that allow a difference:
-
 \begin{itemize}
 \item
 If the original
@@ -8720,7 +8695,6 @@ of \tcode{P} for type deduction and for any further references to or transformat
 If
 \tcode{A}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -8766,7 +8740,6 @@ values that will make the deduced
 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,
@@ -8811,7 +8784,6 @@ the argument template and template-1 as the parameter template.
 \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
@@ -8839,7 +8811,6 @@ and
 \pnum
 Before the partial ordering is done, certain transformations are performed
 on the types used for partial ordering:
-
 \begin{itemize}
 \item
 If
@@ -9043,7 +9014,6 @@ A given type
 \tcode{P}
 can be composed from a number of other
 types, templates, and constant template argument values:
-
 \begin{itemize}
 \item
 A function type includes the types of each of the function parameters,
@@ -9085,7 +9055,6 @@ need not have the same form.
 
 \pnum
 The non-deduced contexts are:
-
 \indextext{context!non-deduced}%
 \begin{itemize}
 \item
@@ -9180,7 +9149,6 @@ is deduced.
 \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@ };
@@ -9197,7 +9165,6 @@ Here is an example where two template arguments are deduced from a
 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));
 
@@ -9214,7 +9181,6 @@ void r() {
 
 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 { };
@@ -9233,7 +9199,6 @@ void h() {
 
 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;
@@ -9244,7 +9209,6 @@ void s() {
 
 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 838d2254..9ea022ab 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -7614,7 +7614,6 @@ and visible to other threads.
 
 \pnum
 The expression \tcode{m.lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -7657,7 +7656,6 @@ that a deadlock would occur.
 
 \pnum
 The expression \tcode{m.try_lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -7703,7 +7701,6 @@ Nothing.
 
 \pnum
 The expression \tcode{m.unlock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -7858,7 +7855,6 @@ requirements\iref{thread.req.lockable.timed}.
 \pnum
 The expression \tcode{m.try_lock_for(rel_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -7900,7 +7896,6 @@ Timeout-related exceptions\iref{thread.req.timing}.
 \pnum
 The expression \tcode{m.try_lock_until(abs_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -8087,7 +8082,6 @@ shared lock.
 \pnum
 The expression \tcode{m.lock_shared()} is well-formed and has the
 following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -8124,7 +8118,6 @@ The calling thread has a shared lock on the mutex.
 
 \pnum
 The expression \tcode{m.unlock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -8149,7 +8142,6 @@ Nothing.
 
 \pnum
 The expression \tcode{m.try_lock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -8252,7 +8244,6 @@ requirements\iref{thread.req.lockable.shared.timed}.
 \pnum
 The expression \tcode{m.try_lock_shared_for(rel_time)} is well-formed and
 has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -8297,7 +8288,6 @@ Timeout-related exceptions\iref{thread.req.timing}.
 \pnum
 The expression \tcode{m.try_lock_shared_until(abs_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -10448,7 +10438,6 @@ template<class Lock, class Clock, class Duration>
 \begin{itemdescr}
 \pnum
 \effects
-
 \begin{itemize}
 \item
 \indextext{block (execution)}%
@@ -11838,7 +11827,6 @@ shared state as \tcode{*this}.
 
 \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}.
@@ -11901,7 +11889,6 @@ already has a stored value or exception.
 
 \pnum
 \errors
-
 \begin{itemize}
 \item \tcode{promise_already_satisfied} if its shared state
 already has a stored value or exception.
@@ -12241,7 +12228,6 @@ the relative timeout\iref{thread.req.timing} specified by \tcode{rel_time} has e
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -12585,7 +12571,6 @@ the relative timeout\iref{thread.req.timing} specified by
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -12620,7 +12605,6 @@ absolute timeout\iref{thread.req.timing} specified by
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -12676,7 +12660,6 @@ The further behavior
 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 3f52ae04..f75f6adb 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2076,7 +2076,6 @@ return os << s.str();
 \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},
@@ -2954,7 +2953,6 @@ for (auto i = 0; i < 8; ++i, u += 250ms)
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2015-06-30 23:59:59.500 UTC
 2015-06-30 23:59:59.750 UTC
@@ -3160,7 +3158,6 @@ cout << format("{0:%F %T %Z} == {1:%F %T %Z}\n", st, tt);
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2000-01-01 00:00:00 UTC == 2000-01-01 00:00:32 TAI
 \end{outputblock}
@@ -3323,7 +3320,6 @@ cout << format("{0:%F %T %Z} == {1:%F %T %Z}\n", st, gt);
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2000-01-01 00:00:00 UTC == 2000-01-01 00:00:13 GPS
 \end{outputblock}
@@ -3392,7 +3388,6 @@ such as \tcode{std::file\-sys\-tem}.
 \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@>
@@ -3401,9 +3396,7 @@ template<class Duration>
   static file_time<@\seebelow@>
     from_sys(const sys_time<Duration>&);
 \end{codeblock}
-
 or:
-
 \begin{codeblock}
 template<class Duration>
   static utc_time<@\seebelow@>
@@ -3876,7 +3869,6 @@ template<class DestClock, class SourceClock, class Duration>
 \constraints
 At least one of the following clock time conversion expressions
 is well-formed:
-
 \begin{itemize}
 \item
 \begin{codeblock}
@@ -7922,7 +7914,6 @@ a conventional syntax for the creation of civil calendar dates.
 \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}}@
@@ -7930,7 +7921,6 @@ The year, month, and day are accepted in any of the following 3 orders:
 \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}}@]
@@ -7943,7 +7933,6 @@ last
 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;
@@ -9135,7 +9124,6 @@ template<class Duration>
 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"
@@ -9165,7 +9153,6 @@ int main() {
 \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
@@ -9210,7 +9197,6 @@ template<class Duration>
 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"
@@ -9238,7 +9224,6 @@ int main() {
 \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
@@ -9292,7 +9277,6 @@ The \tcode{offset} data member indicates
 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}
@@ -9597,7 +9581,6 @@ the behavior of \tcode{zoned_time<Duration, TimeZonePtr>}
 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*> {
@@ -10173,7 +10156,6 @@ for (auto& l : get_tzdb().leap_seconds)
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 1972-07-01 00:00:00: 1s
 1973-01-01 00:00:00: 1s
@@ -10472,7 +10454,6 @@ The \tcode{parse} member functions of these formatters
 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 68918746..0287e368 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -286,7 +286,6 @@ Exchanges the values of \tcode{a} and \tcode{b}.
 \pnum
 \remarks
 The exception specification is equivalent to:
-
 \begin{codeblock}
 is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>
 \end{codeblock}
@@ -2514,7 +2513,6 @@ For all $i$, assigns \tcode{std::forward<$\tcode{T}_i$>(get<$i$>(u))} to
 \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}
@@ -3460,7 +3458,6 @@ As if by \tcode{x.swap(y)}.
 \pnum
 \remarks
 The exception specification is equivalent to:
-
 \begin{codeblock}
 noexcept(x.swap(y))
 \end{codeblock}
@@ -11307,7 +11304,6 @@ constexpr bitset& operator<<=(size_t pos) noexcept;
 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;
@@ -11332,7 +11328,6 @@ constexpr bitset& operator>>=(size_t pos) noexcept;
 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;
@@ -12061,7 +12056,6 @@ namespace std {
 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}
@@ -15544,7 +15538,6 @@ friend bool operator==(const copyable_function& f, nullptr_t) noexcept;
 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}.
-- 
2.43.0


From bb467b40d3d872e8814b31fc1aa9832d651e497a Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Thu, 17 Sep 2020 10:17:47 +0200
Subject: [PATCH 5/9] Use monospace font for code in figures.

---
 source/assets/figdag.dot         |  8 ++++----
 source/assets/figname.dot        | 14 +++++++-------
 source/assets/fignonvirt.dot     | 12 ++++++------
 source/assets/figvirt.dot        | 10 +++++-----
 source/assets/figvirtnonvirt.dot | 14 +++++++-------
 5 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/source/assets/figdag.dot b/source/assets/figdag.dot
index b29593a9..797d8f2b 100644
--- a/source/assets/figdag.dot
+++ b/source/assets/figdag.dot
@@ -1,10 +1,10 @@
 digraph dag {
     graph [nodesep=1.5, rankdir=BT];
 
-    Base [shape=plaintext, height=.1, fontsize=24];
-    Derived1 [shape=plaintext, height=.1, fontsize=24];
-    Derived2 [shape=plaintext, height=.1, fontsize=24];
+    Base [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Derived1 [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Derived2 [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     Derived2 -> Derived1;
     Derived1 -> Base;
-}
\ No newline at end of file
+}
diff --git a/source/assets/figname.dot b/source/assets/figname.dot
index 8cb94e93..9878984d 100644
--- a/source/assets/figname.dot
+++ b/source/assets/figname.dot
@@ -1,12 +1,12 @@
 digraph virt {
     graph [nodesep=1.5, rankdir=BT];
 
-    W1 [label = "W", shape=plaintext, height=.1, fontsize=24];
-    V [shape=plaintext, height=.1, fontsize=24];
-    W2 [label = "W", shape=plaintext, height=.1, fontsize=24];
-    B [shape=plaintext, height=.1, fontsize=24];
-    C [shape=plaintext, height=.1, fontsize=24];
-    D [shape=plaintext, height=.1, fontsize=24];
+    W1 [label = "W", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    V [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    W2 [label = "W", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    C [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    D [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     D -> B;
     D -> C;
@@ -14,4 +14,4 @@ digraph virt {
     C -> V;
     B -> W1;
     C -> W2;
-}
\ No newline at end of file
+}
diff --git a/source/assets/fignonvirt.dot b/source/assets/fignonvirt.dot
index fac23dcf..ee3a3d9b 100644
--- a/source/assets/fignonvirt.dot
+++ b/source/assets/fignonvirt.dot
@@ -1,14 +1,14 @@
 digraph nonvirt {
     graph [nodesep=1.5, rankdir=BT];
 
-    L1 [label = "L", shape=plaintext, height=.1, fontsize=24];
-    L2 [label = "L", shape=plaintext, height=.1, fontsize=24];
-    A [shape=plaintext, height=.1, fontsize=24];
-    B [shape=plaintext, height=.1, fontsize=24];
-    C [shape=plaintext, height=.1, fontsize=24];
+    L1 [label = "L", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    L2 [label = "L", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    A [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    C [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     C -> B;
     C -> A;
     B -> L2;
     A -> L1;
-}
\ No newline at end of file
+}
diff --git a/source/assets/figvirt.dot b/source/assets/figvirt.dot
index 4c9fa775..e1caa157 100644
--- a/source/assets/figvirt.dot
+++ b/source/assets/figvirt.dot
@@ -1,13 +1,13 @@
 digraph virt {
     graph [nodesep=1.5, rankdir=BT];
 
-    V [shape=plaintext, height=.1, fontsize=24];
-    A [shape=plaintext, height=.1, fontsize=24];
-    B [shape=plaintext, height=.1, fontsize=24];
-    C [shape=plaintext, height=.1, fontsize=24];
+    V [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    A [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    C [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     C -> B;
     C -> A;
     B -> V;
     A -> V;
-}
\ No newline at end of file
+}
diff --git a/source/assets/figvirtnonvirt.dot b/source/assets/figvirtnonvirt.dot
index b3c04d48..1ab8e364 100644
--- a/source/assets/figvirtnonvirt.dot
+++ b/source/assets/figvirtnonvirt.dot
@@ -1,12 +1,12 @@
 digraph virtnonvirt {
     graph [nodesep=1.5, rankdir=BT];
 
-    B1 [label = "B", shape=plaintext, height=.1, fontsize=24];
-    B2 [label = "B", shape=plaintext, height=.1, fontsize=24];
-    AA [shape=plaintext, height=.1, fontsize=24];
-    X [shape=plaintext, height=.1, fontsize=24];
-    Y [shape=plaintext, height=.1, fontsize=24];
-    Z [shape=plaintext, height=.1, fontsize=24];
+    B1 [label = "B", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B2 [label = "B", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    AA [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    X [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Y [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Z [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     subgraph {
     AA -> X;
@@ -17,4 +17,4 @@ digraph virtnonvirt {
 
     AA -> Z [weight=0];
     Z  -> B2;
-}
\ No newline at end of file
+}
-- 
2.43.0


From 387317dfd04550872195a9814e2ca9abfeb4894e Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 23 Jun 2021 20:54:27 +0200
Subject: [PATCH 6/9] [uaxid] Mark code that's not to be highlighted.

---
 source/uax31.tex | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/uax31.tex b/source/uax31.tex
index 6574a486..b500e410 100644
--- a/source/uax31.tex
+++ b/source/uax31.tex
@@ -35,8 +35,8 @@ where \tcode{<Start>} has the XID_Start property,
 including the Mathematical Compatibility Notation profile.
 For \Cpp{} we apply the Mathematical Compatibility Notation profile,
 and we add the character \unicode{005f}{low line}, or \tcode{_},
-to the set of permitted \tcode{<Start>} characters.
-The \tcode{<Medial>} set is empty.
+to the set of permitted \noncxxtcode{<Start>} characters.
+The \noncxxtcode{<Medial>} set is empty.
 In the grammar used in \UAX{31}, this is
 \begin{outputblock}
 <Identifier> := <Start> <Continue>*
-- 
2.43.0


From ac3ba32afd33bc4834da156aa2c3210261a8df70 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 28 Jul 2024 10:22:07 +0200
Subject: [PATCH 7/9] Use cxxdraft-htmlgen macros more.

---
 source/algorithms.tex  | 180 +++++++++++++--------------
 source/concepts.tex    |   4 +-
 source/diagnostics.tex |  18 ++-
 source/exec.tex        |  18 +--
 source/future.tex      |  10 +-
 source/iostreams.tex   |  28 ++---
 source/lib-intro.tex   |  28 ++---
 source/memory.tex      |  46 +++----
 source/meta.tex        | 268 ++++++++++++++++++++---------------------
 source/numerics.tex    |  34 +++---
 source/strings.tex     |  10 +-
 source/support.tex     |   4 +-
 source/threads.tex     | 110 ++++++++---------
 source/time.tex        |  66 +++++-----
 source/utilities.tex   | 136 ++++++++++-----------
 15 files changed, 476 insertions(+), 484 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index c9bac8f9..b86bfc2a 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -62,14 +62,14 @@ the names of template parameters are used to express type requirements.
   \tcode{InputIterator1}, or
   \tcode{Input\-Iterator2},
   the template argument shall meet the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
 \item
   If an algorithm's template parameter is named
   \tcode{OutputIterator},
   \tcode{OutputIterator1}, or
   \tcode{Output\-Iterator2},
   the template argument shall meet the
-  \oldconcept{OutputIterator} requirements\iref{output.iterators}.
+  \oldconceptref{OutputIterator} requirements\iref{output.iterators}.
 \item
   If an algorithm's template parameter is named
   \tcode{ForwardIterator},
@@ -77,7 +77,7 @@ the names of template parameters are used to express type requirements.
   \tcode{ForwardItera\-tor2}, or
   \tcode{NoThrowForwardIterator},
   the template argument shall meet the
-  \oldconcept{ForwardIterator} requirements\iref{forward.iterators}
+  \oldconceptref{ForwardIterator} requirements\iref{forward.iterators}
   if it is required to be a mutable iterator, or
   model \libconcept{forward_iterator}\iref{iterator.concept.forward} otherwise.
 \item
@@ -93,7 +93,7 @@ the names of template parameters are used to express type requirements.
   \tcode{Bidirectional\-Iterator1}, or
   \tcode{BidirectionalIterator2},
   the template argument shall meet the
-  \oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators}
+  \oldconceptref{BidirectionalIterator} requirements\iref{bidirectional.iterators}
   if it is required to be a mutable iterator, or model
   \libconcept{bidirectional_iterator}\iref{iterator.concept.bidir} otherwise.
 \item
@@ -102,7 +102,7 @@ the names of template parameters are used to express type requirements.
   \tcode{Random\-AccessIterator1}, or
   \tcode{RandomAccessIterator2},
   the template argument shall meet the
-  \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   if it is required to be a mutable iterator, or model
   \libconcept{random_access_iterator}\iref{iterator.concept.random.access} otherwise.
 \end{itemize}
@@ -4618,10 +4618,10 @@ template<class InputIterator, class Function>
 \pnum
 \expects
 \tcode{Function} meets
-the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}).
+the \oldconceptref{MoveConstructible} requirements (\tref{cpp17.moveconstructible}).
 \begin{note}
 \tcode{Function} need not meet the requirements of
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}).
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}).
 \end{note}
 
 \pnum
@@ -4658,7 +4658,7 @@ template<class ExecutionPolicy, class ForwardIterator, class Function>
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Function} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{Function} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -4792,10 +4792,10 @@ to an integral type\iref{conv.integral,class.conv}.
 \pnum
 \expects
 \tcode{n >= 0} is \tcode{true}.
-\tcode{Function} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{Function} meets the \oldconceptref{MoveConstructible} requirements.
 \begin{note}
 \tcode{Function} need not meet
-the requirements of \oldconcept{CopyConstructible}.
+the requirements of \oldconceptref{CopyConstructible}.
 \end{note}
 
 \pnum
@@ -4832,7 +4832,7 @@ to an integral type\iref{conv.integral,class.conv}.
 \pnum
 \expects
 \tcode{n >= 0} is \tcode{true}.
-\tcode{Function} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{Function} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -5680,7 +5680,7 @@ If
 \item
   the types of \tcode{first1}, \tcode{last1}, \tcode{first2}, and \tcode{last2}
   meet the
-  \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   and \tcode{last1 - first1 != last2 - first2}
   for the overloads in namespace \tcode{std};
 \item
@@ -6024,7 +6024,7 @@ Equivalent to: \tcode{return searcher(first, last).first;}
 
 \pnum
 \remarks
-\tcode{Searcher} need not meet the \oldconcept{CopyConstructible} requirements.
+\tcode{Searcher} need not meet the \oldconceptref{CopyConstructible} requirements.
 \end{itemdescr}
 
 \rSec2[alg.starts.with]{Starts with}
@@ -7597,7 +7597,7 @@ Let $E(\tcode{i})$ be
 \expects
 For the algorithms in namespace \tcode{std},
 the type of \tcode{*first}
-meets the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+meets the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -7848,7 +7848,7 @@ let $E(\tcode{i})$ be
 For the overloads in namespace \tcode{std},
 \tcode{pred} is an equivalence relation and
 the type of \tcode{*first} meets
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -7979,10 +7979,10 @@ Let:
     \libconcept{forward_iterator}\iref{iterator.concept.forward},
     then there are no additional requirements for \tcode{T}.
     Otherwise, if \tcode{OutputIterator} meets
-    the \oldconcept{ForwardIterator} requirements and
+    the \oldconceptref{ForwardIterator} requirements and
     its value type is the same as \tcode{T},
     then \tcode{T} meets
-    the \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+    the \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
     Otherwise, \tcode{T} meets both
     the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
     \oldconcept{CopyAssignable} requirements.
@@ -8061,7 +8061,7 @@ template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-acces
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -8196,10 +8196,10 @@ template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterat
 \range{first}{middle} and \range{middle}{last} are valid ranges.
 For the overloads in namespace \tcode{std},
 \tcode{ForwardIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8419,13 +8419,13 @@ For the overload in namespace \tcode{std}:
 \begin{itemize}
 \item
   \tcode{PopulationIterator} meets
-  the \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  the \oldconceptref{InputIterator} requirements\iref{input.iterators}.
 \item
   \tcode{SampleIterator} meets
-  the \oldconcept{OutputIterator} requirements\iref{output.iterators}.
+  the \oldconceptref{OutputIterator} requirements\iref{output.iterators}.
 \item
   \tcode{SampleIterator} meets
-  the \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  the \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   unless \tcode{Pop\-ulat\-ion\-Iter\-ator}
   models \libconcept{forward_iterator}\iref{iterator.concept.forward}.
 \item
@@ -8493,7 +8493,7 @@ For the overload in namespace \tcode{std}:
 \begin{itemize}
 \item
   \tcode{RandomAccessIterator} meets
-  the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}.
+  the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 \item
   The type \tcode{remove_reference_t<UniformRandomBitGenerator>} meets
   the uniform random bit generator\iref{rand.req.urng} requirements.
@@ -8554,7 +8554,7 @@ template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-acces
 \expects
 \tcode{n >= 0} is \tcode{true}.
 For the overloads in namespace \tcode{std},
-the type of \tcode{*first} meets the \oldconcept{MoveAssignable} requirements.
+the type of \tcode{*first} meets the \oldconceptref{MoveAssignable} requirements.
 
 \pnum
 \effects
@@ -8618,10 +8618,10 @@ template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-acces
 \expects
 \tcode{n >= 0} is \tcode{true}.
 For the overloads in namespace \tcode{std},
-the type of \tcode{*first} meets the \oldconcept{MoveAssignable} requirements,
+the type of \tcode{*first} meets the \oldconceptref{MoveAssignable} requirements,
 and \tcode{ForwardIterator} meets
-the \oldconcept{BidirectionalIterator} requirements\iref{bidirectional.iterators} or
-the \oldconcept{ValueSwap\-pable} requirements.
+the \oldconceptref{BidirectionalIterator} requirements\iref{bidirectional.iterators} or
+the \oldconceptref{ValueSwappable} requirements.
 
 \pnum
 \effects
@@ -8800,10 +8800,10 @@ for the overloads with no parameters by those names.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8868,10 +8868,10 @@ for the overloads with no parameters by those names.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -8942,10 +8942,10 @@ for the overloads with no parameters by those names.
 \range{first}{middle} and \range{middle}{last} are valid ranges.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -9089,10 +9089,10 @@ is writable\iref{iterator.requirements.general} to \tcode{result_first}.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements},
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements},
 the type of \tcode{*result_first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{\-Move\-Assignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 For iterators \tcode{a1} and \tcode{b1} in \range{first}{last}, and
@@ -9327,10 +9327,10 @@ for the overloads with no parameters by those names.
 \range{first}{nth} and \range{nth}{last} are valid ranges.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -9712,7 +9712,7 @@ and let $E(x)$ be \tcode{bool(invoke(\brk{}pred, invoke(proj, $x$)))}.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{ForwardIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -9739,7 +9739,7 @@ Let $N = \tcode{last - first}$:
   For the non-parallel algorithm overloads,
   exactly $N$ applications of the predicate and projection.
   At most $N / 2$ swaps if the type of \tcode{first} meets
-  the \oldconcept{BidirectionalIterator} requirements
+  the \oldconceptref{BidirectionalIterator} requirements
   for the overloads in namespace \tcode{std} or
   models \libconcept{bidirectional_iterator}
   for the overloads in namespace \tcode{ranges},
@@ -9792,10 +9792,10 @@ and let $E(x)$ be \tcode{bool(invoke(\brk{}pred, invoke(proj, $x$)))}.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -10192,10 +10192,10 @@ for the overloads with no parameters by those names.
 sorted with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -10958,10 +10958,10 @@ The range \range{first}{last - 1}
 is a valid heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}) and
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
+the \oldconceptref{MoveConstructible} requirements (\tref{cpp17.moveconstructible}) and
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -11011,10 +11011,10 @@ The range \range{first}{last}
 is a valid non-empty heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -11067,10 +11067,10 @@ for the overloads with no parameters by those names.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwap\-pable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -11120,10 +11120,10 @@ The range \range{first}{last} is
 a valid heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 \tcode{RandomAccessIterator} meets
-the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} meets
-the \oldconcept{MoveConst\-ruct\-ible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{Move\-Assign\-able} (\tref{cpp17.moveassignable}) requirements.
+the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -11310,7 +11310,7 @@ template<class T, class Proj = identity,
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -11355,8 +11355,8 @@ template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-acces
 \expects
 \tcode{ranges::distance(r) > 0}.
 For the overloads in namespace \tcode{std},
-\tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
-For the first form, \tcode{T} meets the \oldconcept{LessThanComparable}
+\tcode{T} meets the \oldconceptref{CopyConstructible} requirements.
+For the first form, \tcode{T} meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -11393,7 +11393,7 @@ template<class T, class Proj = identity,
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -11438,8 +11438,8 @@ template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-acces
 \expects
 \tcode{ranges::distance(r) > 0}.
 For the overloads in namespace \tcode{std},
-\tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
-For the first form, \tcode{T} meets the \oldconcept{LessThanComparable}
+\tcode{T} meets the \oldconceptref{CopyConstructible} requirements.
+For the first form, \tcode{T} meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -11478,7 +11478,7 @@ template<class T, class Proj = identity,
 \pnum
 \expects
 For the first form, \tcode{T} meets the
-\oldconcept{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
+\oldconceptref{LessThanComparable} requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -11524,8 +11524,8 @@ template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-acces
 \expects
 \tcode{ranges::distance(r) > 0}.
 For the overloads in namespace \tcode{std},
-\tcode{T} meets the \oldconcept{\-Copy\-Constructible} requirements.
-For the first form, type \tcode{T} meets the \oldconcept{LessThanComparable}
+\tcode{T} meets the \oldconceptref{CopyConstructible} requirements.
+For the first form, type \tcode{T} meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -11747,7 +11747,7 @@ for the overloads with no parameter \tcode{proj}.
 \expects
 \tcode{bool(invoke(comp, invoke(proj, hi), invoke(proj, lo)))} is \tcode{false}.
 For the first form, type \tcode{T}
-meets the \oldconcept{LessThan\-Comparable}
+meets the \oldconceptref{LessThanComparable}
 requirements (\tref{cpp17.lessthancomparable}).
 
 \pnum
@@ -11950,7 +11950,7 @@ for overloads with no parameters by those names.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -12009,7 +12009,7 @@ for overloads with no parameters by those names.
 \expects
 For the overloads in namespace \tcode{std},
 \tcode{BidirectionalIterator} meets
-the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements}.
+the \oldconceptref{ValueSwappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -12328,8 +12328,8 @@ template<class InputIterator, class T, class BinaryOperation>
 \pnum
 \expects
 \tcode{T} meets
-the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 In the range \crange{first}{last},
 \tcode{binary_op} neither modifies elements
 nor invalidates iterators or subranges.
@@ -12451,7 +12451,7 @@ are convertible to \tcode{T}.
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in the range \crange{first}{last}.
@@ -12495,8 +12495,8 @@ template<class InputIterator1, class InputIterator2, class T,
 \pnum
 \expects
 \tcode{T} meets
-the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 In the ranges \crange{first1}{last1} and
 \crange{first2}{first2 + (last1 - first1)}
 \tcode{binary_op1} and \tcode{binary_op2}
@@ -12591,7 +12591,7 @@ All of
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   Neither \tcode{binary_op1} nor \tcode{binary_op2}
   invalidates subranges, nor modifies elements in the ranges
@@ -12641,7 +12641,7 @@ template<class ExecutionPolicy,
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op} invalidates subranges,
   nor modifies elements in the range \crange{first}{last}.
@@ -12790,7 +12790,7 @@ template<class ExecutionPolicy,
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in
@@ -12911,9 +12911,9 @@ is convertible to \tcode{U}.
 \begin{itemize}
 \item
   If \tcode{init} is provided,
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
   otherwise, \tcode{U}
-  meets the \oldconcept{MoveConstructible} requirements.
+  meets the \oldconceptref{MoveConstructible} requirements.
 \item
   \tcode{binary_op} neither invalidates iterators or subranges,
   nor modifies elements in
@@ -12990,7 +12990,7 @@ template<class ExecutionPolicy,
 \expects
 \begin{itemize}
 \item
-  \tcode{T} meets the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
+  \tcode{T} meets the \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op}
   invalidates iterators or subranges, nor modifies elements in
@@ -13089,9 +13089,9 @@ is convertible to \tcode{U}.
 \begin{itemize}
 \item
   If \tcode{init} is provided, \tcode{T} meets the
-  \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
+  \oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) requirements;
   otherwise, \tcode{U} meets the
-  \oldconcept{MoveConstructible} requirements.
+  \oldconceptref{MoveConstructible} requirements.
 \item
   Neither \tcode{unary_op} nor \tcode{binary_op} invalidates
   iterators or subranges, nor modifies elements in
@@ -13190,7 +13190,7 @@ that denotes an object of type \tcode{minus<>}.
 \begin{itemize}
 \item
   For the overloads with no \tcode{ExecutionPolicy},
-  \tcode{T} meets the \oldconcept{MoveAssignable} (\tref{cpp17.moveassignable})
+  \tcode{T} meets the \oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable})
   requirements.
 \item
   For all overloads, in the ranges \crange{first}{last}
diff --git a/source/concepts.tex b/source/concepts.tex
index 3e64abc8..9efb5afa 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -495,7 +495,7 @@ template<class T>
 template<class T>
   concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;
 template<class T>
-  concept @\deflibconcept{floating_point}@ = @\libglobalref{is_floating_point_v}@<T>;
+  concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -747,7 +747,7 @@ template<class T>
 \begin{itemdescr}
 \pnum
 \begin{note}
-Unlike the \oldconcept{Destructible} requirements~(\tref{cpp17.destructible}), this
+Unlike the \oldconceptref{Destructible} requirements~(\tref{cpp17.destructible}), this
 concept forbids destructors that are potentially throwing, even if a particular
 invocation of the destructor does not actually throw.
 \end{note}
diff --git a/source/diagnostics.tex b/source/diagnostics.tex
index 89419def..15edbb54 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -761,9 +761,9 @@ namespace std {
 
   // \ref{syserr}, system error support
   template<class T>
-    constexpr bool @\libglobal{is_error_code_enum_v}@ = is_error_code_enum<T>::value;
+    constexpr bool @\libglobal{is_error_code_enum_v}@ = @\libglobalref{is_error_code_enum}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_error_condition_enum_v}@ = is_error_condition_enum<T>::value;
+    constexpr bool @\libglobal{is_error_condition_enum_v}@ = @\libglobalref{is_error_condition_enum}@<T>::value;
 
   // \ref{syserr.fmt}, formatter
   template<class T> struct formatter<error_code, charT>;
@@ -777,9 +777,9 @@ Whether or not the \libheader{system_error} implementation
 exposes the \libheader{cerrno} macros is unspecified.
 
 \pnum
-The \tcode{is_error_code_enum} and \tcode{is_error_condition_enum} templates may be
+The \libglobalref{is_error_code_enum} and \libglobalref{is_error_condition_enum} templates may be
 specialized for program-defined types to indicate that such types are eligible
-for \tcode{class error_code} and \tcode{class error_condition} implicit
+for \tcode{class \libglobalref{error_code}} and \tcode{class \libglobalref{error_condition}} implicit
 conversions, respectively.
 
 \rSec2[syserr.errcat]{Class \tcode{error_category}}
@@ -804,8 +804,6 @@ even for objects holding the same value.
 \indexlibraryglobal{error_category}%
 \indexlibraryctor{error_category}%
 \indexlibrarydtor{error_category}%
-\indexlibraryglobal{generic_category}%
-\indexlibraryglobal{system_category}%
 \begin{codeblock}
 namespace std {
   class error_category {
@@ -824,8 +822,8 @@ namespace std {
     strong_ordering operator<=>(const error_category& rhs) const noexcept;
   };
 
-  const error_category& generic_category() noexcept;
-  const error_category& system_category() noexcept;
+  const error_category& @\libglobal{generic_category}@() noexcept;
+  const error_category& @\libglobal{system_category}@() noexcept;
 }
 \end{codeblock}
 
@@ -1097,7 +1095,7 @@ template<class ErrorCodeEnum>
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{is_error_code_enum_v<ErrorCodeEnum>} is \tcode{true}.
+\tcode{\libglobalref{is_error_code_enum_v}<ErrorCodeEnum>} is \tcode{true}.
 
 \pnum
 \effects
@@ -1130,7 +1128,7 @@ template<class ErrorCodeEnum>
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{is_error_code_enum_v<ErrorCodeEnum>} is \tcode{true}.
+\tcode{\libglobalref{is_error_code_enum_v}<ErrorCodeEnum>} is \tcode{true}.
 
 \pnum
 \effects
diff --git a/source/exec.tex b/source/exec.tex
index 2fd6f4f2..4acd1841 100644
--- a/source/exec.tex
+++ b/source/exec.tex
@@ -31,25 +31,25 @@ used in the execution control library.
 \capsep
 core &
   provide core execution functionality, and connection between core components &
-  e.g., \tcode{connect}, \tcode{start} \\
+  e.g., \libglobalref{connect}, \libglobalref{start} \\
 completion functions &
   called by senders to announce the completion of the work (success, error, or cancellation) &
-  \tcode{set_value}, \tcode{set_error}, \tcode{set_stopped} \\
+  \libglobalref{set_value}, \libglobalref{set_error}, \libglobalref{set_stopped} \\
 senders &
   allow the specialization of the provided sender algorithms &
   \begin{itemize}
-  \item sender factories (e.g., \tcode{schedule}, \tcode{just}, \tcode{read_env})
-  \item sender adaptors (e.g., \tcode{continues_on}, \tcode{then}, \tcode{let_value})
-  \item sender consumers (e.g., \tcode{sync_wait})
+  \item sender factories (e.g., \libglobalref{schedule}, \libglobalref{just}, \libglobalref{read_env})
+  \item sender adaptors (e.g., \libglobalref{continues_on}, \libglobalref{then}, \libglobalref{let_value})
+  \item sender consumers (e.g., \libglobalref{sync_wait})
   \end{itemize}
     \\
 queries &
   allow querying different properties of objects &
   \begin{itemize}
-  \item general queries (e.g., \tcode{get_allocator}, \tcode{get_stop_token})
-  \item environment queries (e.g., \tcode{get_scheduler}, \tcode{get_delegation_scheduler})
-  \item scheduler queries (e.g., \tcode{get_forward_progress_guarantee})
-  \item sender attribute queries (e.g., \tcode{get_completion_scheduler})
+  \item general queries (e.g., \libglobalref{get_allocator}, \libglobalref{get_stop_token})
+  \item environment queries (e.g., \tcode{get_scheduler}, \libglobalref{get_delegation_scheduler})
+  \item scheduler queries (e.g., \libglobalref{get_forward_progress_guarantee})
+  \item sender attribute queries (e.g., \libglobalref{get_completion_scheduler})
   \end{itemize}
     \\
 \end{floattable}
diff --git a/source/future.tex b/source/future.tex
index 68cdef6e..02a76d83 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -359,7 +359,7 @@ template<class T> struct is_pod;
 
 \pnum
 \remarks
-\tcode{is_pod<T>} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\tcode{is_pod<T>} is a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of \tcode{true_type}
 if \tcode{T} is a POD type,
 and \tcode{false_type} otherwise.
@@ -543,7 +543,7 @@ Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}
 If the expression \tcode{TS::value} is well-formed
 when treated as an \deflink{unevaluated operand}{expr.context},
 then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements with a base characteristic of
+the \oldconceptref{TransformationTrait} requirements with a base characteristic of
 \tcode{integral_constant<size_t, TS::value>}.
 Otherwise, they have no member \tcode{value}.
 
@@ -571,7 +571,7 @@ template<size_t I, class T> struct tuple_element<I, const volatile T>;
 Let \tcode{TE} denote \tcode{tuple_element_t<I, T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements
+the \oldconceptref{TransformationTrait} requirements
 with a member typedef \tcode{type} that names the following type:
 \begin{itemize}
 \item for the first specialization, \tcode{volatile TE}, and
@@ -611,7 +611,7 @@ template<class T> struct variant_size<const volatile T>;
 Let \tcode{VS} denote \tcode{variant_size<T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{UnaryTypeTrait} requirements
+the \oldconceptref{UnaryTypeTrait} requirements
 with a base characteristic of \tcode{integral_constant<size_t, VS::value>}.
 \end{itemdescr}
 
@@ -625,7 +625,7 @@ template<size_t I, class T> struct variant_alternative<I, const volatile T>;
 Let \tcode{VA} denote \tcode{variant_alternative<I, T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements
+the \oldconceptref{TransformationTrait} requirements
 with a member typedef \tcode{type} that names the following type:
 \begin{itemize}
 \item for the first specialization, \tcode{volatile VA::type}, and
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 297a4fcb..3eb7d9ee 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -1684,10 +1684,10 @@ An \tcode{fpos} type specifies file position information.
 It holds a state object
 whose type is equal to the template parameter \tcode{stateT}.
 Type \tcode{stateT} shall meet
-the \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+the \oldconceptref{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}), and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 If \tcode{is_trivially_copy_constructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy constructor.
 If \tcode{is_trivially_copy_assignable_v<stateT>} is \tcode{true},
@@ -1695,11 +1695,11 @@ then \tcode{fpos<stateT>} has a trivial copy assignment operator.
 If \tcode{is_trivially_destructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial destructor.
 All specializations of \tcode{fpos} meet
-the \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable},
-\oldconcept{Destructible},
-and \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable},
+\oldconceptref{Destructible},
+and \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 In addition, the expressions shown in \tref{fpos.operations}
 are valid and have the indicated semantics.
 In that table,
@@ -12921,7 +12921,7 @@ namespace std {
 
 \pnum
 \tcode{Allocator} shall meet
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \begin{example}
@@ -13214,7 +13214,7 @@ unless \tcode{EcharT} is one of the encoded character types.
 
 \pnum
 Template parameters named \tcode{InputIterator} shall meet the
-\oldconcept{InputIterator} requirements\iref{input.iterators} and shall
+\oldconceptref{InputIterator} requirements\iref{input.iterators} and shall
 have a value type that is one of the encoded character types.
 
 \pnum
@@ -13228,7 +13228,7 @@ they are not included as permitted types.
 
 \pnum
 Template parameters named \tcode{Allocator} shall meet
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \rSec2[fs.filesystem.syn]{Header \tcode{<filesystem>} synopsis}
 
@@ -14047,7 +14047,7 @@ shall be one of:
 \item \tcode{basic_string_view<EcharT, traits>}. A function
   argument \tcode{const Source\&} \tcode{source} shall have an
   effective range \range{source.begin()}{source.end()}.
-\item A type meeting the \oldconcept{InputIterator} requirements that iterates over an NTCTS\@.
+\item A type meeting the \oldconceptref{InputIterator} requirements that iterates over an NTCTS\@.
   The value type shall be an encoded character type. A function argument
   \tcode{const Source\&} \tcode{source} shall have an effective range
   \range{source}{end} where \tcode{end} is the first
@@ -16552,7 +16552,7 @@ namespace std::filesystem {
 
 \pnum
 \tcode{directory_iterator} meets the
-\oldconcept{InputIterator} requirements\iref{input.iterators}.
+\oldconceptref{InputIterator} requirements\iref{input.iterators}.
 
 \pnum
 If an iterator of type \tcode{directory_iterator} reports an error or
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 5597e57d..2149f97a 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -1868,7 +1868,7 @@ If \tcode{a == b} and \tcode{b == c}, then \tcode{a == c}.
 }\\
 \end{oldconcepttable}
 
-\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconcept{MoveConstructible})}{cpp17.copyconstructible}
+\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconceptref{MoveConstructible})}{cpp17.copyconstructible}
 {p{1in}p{4.15in}}
 \topline
 \hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
@@ -1895,7 +1895,7 @@ If \tcode{a == b} and \tcode{b == c}, then \tcode{a == c}.
 }\\
 \end{oldconcepttable}
 
-\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconcept{MoveAssignable})}{cpp17.copyassignable}
+\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconceptref{MoveAssignable})}{cpp17.copyassignable}
 {p{1in}p{1in}p{1in}p{1.9in}}
 \topline
 \hdstyle{Expression} & \hdstyle{Return type} & \hdstyle{Return value} & \hdstyle{Post-condition} \\ \capsep
@@ -1909,7 +1909,7 @@ If \tcode{a == b} and \tcode{b == c}, then \tcode{a == c}.
 \tcode{a.\~T()} & No exception is propagated. \\ \rowsep
 \multicolumn{2}{|l|}{
   \begin{tailnote}
-  Array types and non-object types are not \oldconcept{Destructible}.
+  Array types and non-object types are not \oldconceptref{Destructible}.
   \end{tailnote}
 } \\
 \end{oldconcepttable}
@@ -1988,7 +1988,7 @@ void value_swap(T&& t, U&& u) {
                                                 // for rvalues and lvalues
 }
 
-// Preconditions: \tcode{T} meets the \oldconcept{Swappable} requirements.
+// Preconditions: \tcode{T} meets the \oldconceptref{Swappable} requirements.
 template<class T>
 void lv_swap(T& t1, T& t2) {
   using std::swap;
@@ -2025,9 +2025,9 @@ int main() {
 A \oldconcept{NullablePointer} type is a pointer-like type that supports null values.
 A type \tcode{P} meets the \oldconcept{\-Nullable\-Pointer} requirements if
 \begin{itemize}
-\item \tcode{P} meets the \oldconcept{EqualityComparable},
-\oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
-\oldconcept{Swappable}, and \oldconcept{Destructible} requirements,
+\item \tcode{P} meets the \oldconceptref{EqualityComparable},
+\oldconceptref{DefaultConstructible}, \oldconceptref{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
+\oldconceptref{Swappable}, and \oldconceptref{Destructible} requirements,
 
 \item the expressions shown in \tref{cpp17.nullablepointer} are
 valid and have the indicated semantics, and
@@ -2103,8 +2103,8 @@ a value of type (possibly const) \tcode{std::nullptr_t}.
 A type \tcode{H} meets the \defnoldconcept{Hash} requirements if
 \begin{itemize}
 \item it is a function object type\iref{function.objects},
-\item it meets the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
-  \oldconcept{Destructible} (\tref{cpp17.destructible}) requirements, and
+\item it meets the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}) and
+  \oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements, and
 \item the expressions shown in \tref{cpp17.hash}
 are valid and have the indicated semantics.
 \end{itemize}
@@ -2788,7 +2788,7 @@ Identical to or derived from \tcode{true_type} or \tcode{false_type}.
 \tcode{true_type} only if an allocator of type \tcode{X} should be copied
 when the client container is copy-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
+the \oldconceptref{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
 the copy operation shall not throw exceptions.
 
 \pnum
@@ -2810,7 +2810,7 @@ Identical to or derived from \tcode{true_type} or \tcode{false_type}.
 \tcode{true_type} only if an allocator of type \tcode{X} should be moved
 when the client container is move-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
 the move operation shall not throw exceptions.
 
 \pnum
@@ -2832,7 +2832,7 @@ Identical to or derived from \tcode{true_type} or \tcode{false_type}.
 \tcode{true_type} only if an allocator of type \tcode{X} should be swapped
 when the client container is swapped;
 if so,
-\tcode{X} shall meet the \oldconcept{Swappable} requirements\iref{swappable.requirements} and
+\tcode{X} shall meet the \oldconceptref{Swappable} requirements\iref{swappable.requirements} and
 the \tcode{swap} operation shall not throw exceptions.
 
 \pnum
@@ -2862,7 +2862,7 @@ Default: \tcode{is_empty<X>::type}
 
 \pnum
 An allocator type \tcode{X} shall meet the
-\oldconcept{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
+\oldconceptref{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
 The \tcode{XX::pointer}, \tcode{XX::const_pointer}, \tcode{XX::void_pointer}, and
 \tcode{XX::const_void_pointer} types shall meet the
 \oldconcept{Nullable\-Pointer} requirements (\tref{cpp17.nullablepointer}).
@@ -2870,7 +2870,7 @@ No constructor,
 comparison operator function, copy operation, move operation, or swap operation on
 these pointer types shall exit via an exception. \tcode{XX::pointer} and \tcode{XX::const_pointer} shall also
 meet the requirements for
-a \oldconcept{RandomAccessIterator}\iref{random.access.iterators} and
+a \oldconceptref{RandomAccessIterator}\iref{random.access.iterators} and
 the additional requirement that, when \tcode{p} and \tcode{(p + n)} are
 dereferenceable pointer values for some integral value \tcode{n},
 \begin{codeblock}
diff --git a/source/memory.tex b/source/memory.tex
index e89f767b..8fb09ade 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -1227,7 +1227,7 @@ The \tcode{allocator_arg_t} struct is an empty class type used as a unique type
 disambiguate constructor and function overloading. Specifically, several types (see
 \tcode{tuple}~\ref{tuple}) have constructors with \tcode{allocator_arg_t} as the first
 argument, immediately followed by an argument of a type that meets the
-\oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+\oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \rSec2[allocator.uses]{\tcode{uses_allocator}}
 
@@ -1242,7 +1242,7 @@ template<class T, class Alloc> struct uses_allocator;
 \pnum
 \remarks
 Automatically detects whether \tcode{T} has a nested \tcode{allocator_type} that
-is convertible from \tcode{Alloc}. Meets the \oldconcept{BinaryTypeTrait}
+is convertible from \tcode{Alloc}. Meets the \oldconceptref{BinaryTypeTrait}
 requirements\iref{meta.rqmts}. The implementation shall provide a definition that is
 derived from \tcode{true_type} if the \grammarterm{qualified-id} \tcode{T::allocator_type}
 is valid and denotes a type\iref{temp.deduct} and
@@ -2614,8 +2614,8 @@ deleter before such replacement is considered completed.
 Each object of a type \tcode{U} instantiated from the \tcode{unique_ptr} template
 specified in \ref{unique.ptr} has the strict ownership semantics, specified above,
 of a unique pointer. In partial satisfaction of these semantics, each such \tcode{U}
-is \oldconcept{MoveConstructible} and \oldconcept{MoveAssignable}, but is not
-\oldconcept{CopyConstructible} nor \oldconcept{CopyAssignable}.
+is \oldconceptref{MoveConstructible} and \oldconceptref{MoveAssignable}, but is not
+\oldconceptref{CopyConstructible} nor \oldconceptref{CopyAssignable}.
 The template parameter \tcode{T} of \tcode{unique_ptr} may be an incomplete type.
 
 \pnum
@@ -2802,7 +2802,7 @@ pointer as appropriate for that deleter.
 
 \pnum
 If the deleter's type \tcode{D} is not a reference type, \tcode{D} shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 
 \pnum
 If the \grammarterm{qualified-id} \tcode{remove_reference_t<D>::pointer} is valid and denotes a
@@ -2810,7 +2810,7 @@ type\iref{temp.deduct}, then \tcode{unique_ptr<T,
 D>::pointer} shall be a synonym for \tcode{remove_reference_t<D>::pointer}. Otherwise
 \tcode{unique_ptr<T, D>::pointer} shall be a synonym for \tcode{element_type*}. The type \tcode{unique_ptr<T,
 D>::pointer} shall
-meet the \oldconcept{NullablePointer} requirements (\tref{cpp17.nullablepointer}).
+meet the \oldconceptref{NullablePointer} requirements (\tref{cpp17.nullablepointer}).
 
 \pnum
 \begin{example}
@@ -2836,7 +2836,7 @@ constexpr unique_ptr(nullptr_t) noexcept;
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+\tcode{D} meets the \oldconceptref{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
 and that construction does not throw an exception.
 
 \pnum
@@ -2863,7 +2863,7 @@ constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+\tcode{D} meets the \oldconceptref{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
 and that construction does not throw an exception.
 
 \pnum
@@ -2892,10 +2892,10 @@ constexpr unique_ptr(type_identity_t<pointer> p, remove_reference_t<D>&& d) noex
 \pnum
 \expects
 For the first constructor, if \tcode{D} is not a reference type,
-\tcode{D} meets the \oldconcept{CopyConstructible} requirements and
+\tcode{D} meets the \oldconceptref{CopyConstructible} requirements and
 such construction does not exit via an exception.
 For the second constructor, if \tcode{D} is not a reference type,
-\tcode{D} meets the \oldconcept{MoveConstructible} requirements and
+\tcode{D} meets the \oldconceptref{MoveConstructible} requirements and
 such construction does not exit via an exception.
 
 \pnum
@@ -2920,8 +2920,8 @@ the second constructor is defined as deleted.
 \begin{example}
 \begin{codeblock}
 D d;
-unique_ptr<int, D> p1(new int, D());        // \tcode{D} must be \oldconcept{MoveConstructible}
-unique_ptr<int, D> p2(new int, d);          // \tcode{D} must be \oldconcept{CopyConstructible}
+unique_ptr<int, D> p1(new int, D());        // \tcode{D} must be \oldconceptref{MoveConstructible}
+unique_ptr<int, D> p2(new int, d);          // \tcode{D} must be \oldconceptref{CopyConstructible}
 unique_ptr<int, D&> p3(new int, d);         // \tcode{p3} holds a reference to \tcode{d}
 unique_ptr<int, const D&> p4(new int, D()); // error: rvalue deleter object combined
                                             // with reference deleter type
@@ -2942,7 +2942,7 @@ constexpr unique_ptr(unique_ptr&& u) noexcept;
 \pnum
 \expects
 If \tcode{D} is not a reference type,
-\tcode{D} meets the \oldconcept{MoveConstructible}
+\tcode{D} meets the \oldconceptref{MoveConstructible}
 requirements (\tref{cpp17.moveconstructible}).
 Construction
 of the deleter from an rvalue of type \tcode{D} does not
@@ -3051,10 +3051,10 @@ constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;
 \pnum
 \expects
 If \tcode{D} is not a reference type, \tcode{D} meets the
-\oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and assignment
+\oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and assignment
 of the deleter from an rvalue of type \tcode{D} does not throw an exception.
 Otherwise, \tcode{D} is a reference type;
-\tcode{remove_reference_t<D>} meets the \oldconcept{CopyAssignable}
+\tcode{remove_reference_t<D>} meets the \oldconceptref{CopyAssignable}
 requirements and assignment of the deleter from an
 lvalue of type \tcode{D} does not throw an exception.
 
@@ -3956,8 +3956,8 @@ namespace std {
 \end{codeblock}
 
 \pnum
-Specializations of \tcode{shared_ptr} shall be \oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable}, and \oldconcept{\-Less\-Than\-Comparable}, allowing their use in standard
+Specializations of \tcode{shared_ptr} shall be \oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable}, and \oldconceptref{LessThanComparable}, allowing their use in standard
 containers. Specializations of \tcode{shared_ptr} shall be
 contextually convertible to \tcode{bool},
 allowing their use in boolean expressions and declarations in conditions.
@@ -4102,7 +4102,7 @@ initialized with \tcode{std::move(d)} do not throw exceptions.
 The expression \tcode{d(p)}
 has well-defined behavior and does not throw exceptions.
 \tcode{A} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \effects
@@ -4622,7 +4622,7 @@ template<class T, class A, ...>
 \pnum
 \expects
 \tcode{A} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \effects
@@ -5278,8 +5278,8 @@ namespace std {
 \end{codeblock}
 
 \pnum
-Specializations of \tcode{weak_ptr} shall be \oldconcept{CopyConstructible} and
-\oldconcept{CopyAssignable}, allowing their use in standard
+Specializations of \tcode{weak_ptr} shall be \oldconceptref{CopyConstructible} and
+\oldconceptref{CopyAssignable}, allowing their use in standard
 containers.  The template parameter \tcode{T} of \tcode{weak_ptr} may be an
 incomplete type.
 
@@ -5858,7 +5858,7 @@ namespace std {
 \end{codeblock}
 
 \pnum
-\tcode{Pointer} shall meet the \oldconcept{NullablePointer} requirements.
+\tcode{Pointer} shall meet the \oldconceptref{NullablePointer} requirements.
 If \tcode{Smart} is a specialization of \tcode{shared_ptr} and
 \tcode{sizeof...(Args) == 0},
 the program is ill-formed.
@@ -6098,7 +6098,7 @@ namespace std {
 \end{codeblock}
 
 \pnum
-\tcode{Pointer} shall meet the \oldconcept{NullablePointer} requirements.
+\tcode{Pointer} shall meet the \oldconceptref{NullablePointer} requirements.
 If \tcode{Smart} is a specialization of \tcode{shared_ptr},
 the program is ill-formed.
 \begin{note}
diff --git a/source/meta.tex b/source/meta.tex
index 880b68a7..9975819b 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -136,12 +136,12 @@ All functions specified in \ref{type.traits} are signal-safe\iref{support.signal
 A \defnoldconcept{UnaryTypeTrait} describes a property
 of a type. It shall be a class template that takes one template type
 argument and, optionally, additional arguments that help define the
-property being described. It shall be \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
+property being described. It shall be \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
 and publicly and unambiguously derived, directly or indirectly, from
 its \defn{base characteristic}, which is
 a specialization of the template
-\tcode{integral_constant}\iref{meta.help}, with
+\libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
 requirements for the particular property being described.
 The member names of the base characteristic shall not be hidden and shall be
@@ -152,12 +152,12 @@ A \defnoldconcept{BinaryTypeTrait} describes a
 relationship between two types. It shall be a class template that
 takes two template type arguments and, optionally, additional
 arguments that help define the relationship being described. It shall
-be \oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible},
+be \oldconceptref{DefaultConstructible}, \oldconceptref{CopyConstructible},
 and publicly and unambiguously derived, directly or
 indirectly, from
 its \term{base characteristic}, which is a specialization
 of the template
-\tcode{integral_constant}\iref{meta.help}, with
+\libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
 requirements for the particular relationship being described.
 The member names of the base characteristic shall not be hidden and shall be
@@ -328,17 +328,17 @@ namespace std {
   template<class T> struct add_cv;
 
   template<class T>
-    using @\libglobal{remove_const_t}@    = remove_const<T>::type;
+    using @\libglobal{remove_const_t}@    = @\libglobalref{remove_const}@<T>::type;
   template<class T>
-    using @\libglobal{remove_volatile_t}@ = remove_volatile<T>::type;
+    using @\libglobal{remove_volatile_t}@ = @\libglobalref{remove_volatile}@<T>::type;
   template<class T>
-    using @\libglobal{remove_cv_t}@       = remove_cv<T>::type;
+    using @\libglobal{remove_cv_t}@       = @\libglobalref{remove_cv}@<T>::type;
   template<class T>
-    using @\libglobal{add_const_t}@       = add_const<T>::type;
+    using @\libglobal{add_const_t}@       = @\libglobalref{add_const}@<T>::type;
   template<class T>
-    using @\libglobal{add_volatile_t}@    = add_volatile<T>::type;
+    using @\libglobal{add_volatile_t}@    = @\libglobalref{add_volatile}@<T>::type;
   template<class T>
-    using @\libglobal{add_cv_t}@          = add_cv<T>::type;
+    using @\libglobal{add_cv_t}@          = @\libglobalref{add_cv}@<T>::type;
 
   // \ref{meta.trans.ref}, reference modifications
   template<class T> struct remove_reference;
@@ -346,38 +346,38 @@ namespace std {
   template<class T> struct add_rvalue_reference;
 
   template<class T>
-    using @\libglobal{remove_reference_t}@     = remove_reference<T>::type;
+    using @\libglobal{remove_reference_t}@     = @\libglobalref{remove_reference}@<T>::type;
   template<class T>
-    using @\libglobal{add_lvalue_reference_t}@ = add_lvalue_reference<T>::type;
+    using @\libglobal{add_lvalue_reference_t}@ = @\libglobalref{add_lvalue_reference}@<T>::type;
   template<class T>
-    using @\libglobal{add_rvalue_reference_t}@ = add_rvalue_reference<T>::type;
+    using @\libglobal{add_rvalue_reference_t}@ = @\libglobalref{add_rvalue_reference}@<T>::type;
 
   // \ref{meta.trans.sign}, sign modifications
   template<class T> struct make_signed;
   template<class T> struct make_unsigned;
 
   template<class T>
-    using @\libglobal{make_signed_t}@   = make_signed<T>::type;
+    using @\libglobal{make_signed_t}@   = @\libglobalref{make_signed}@<T>::type;
   template<class T>
-    using @\libglobal{make_unsigned_t}@ = make_unsigned<T>::type;
+    using @\libglobal{make_unsigned_t}@ = @\libglobalref{make_unsigned}@<T>::type;
 
   // \ref{meta.trans.arr}, array modifications
   template<class T> struct remove_extent;
   template<class T> struct remove_all_extents;
 
   template<class T>
-    using @\libglobal{remove_extent_t}@      = remove_extent<T>::type;
+    using @\libglobal{remove_extent_t}@      = @\libglobalref{remove_extent}@<T>::type;
   template<class T>
-    using @\libglobal{remove_all_extents_t}@ = remove_all_extents<T>::type;
+    using @\libglobal{remove_all_extents_t}@ = @\libglobalref{remove_all_extents}@<T>::type;
 
   // \ref{meta.trans.ptr}, pointer modifications
   template<class T> struct remove_pointer;
   template<class T> struct add_pointer;
 
   template<class T>
-    using @\libglobal{remove_pointer_t}@ = remove_pointer<T>::type;
+    using @\libglobal{remove_pointer_t}@ = @\libglobalref{remove_pointer}@<T>::type;
   template<class T>
-    using @\libglobal{add_pointer_t}@    = add_pointer<T>::type;
+    using @\libglobal{add_pointer_t}@    = @\libglobalref{add_pointer}@<T>::type;
 
   // \ref{meta.trans.other}, other transformations
   template<class T> struct type_identity;
@@ -396,29 +396,29 @@ namespace std {
   template<class T> struct unwrap_ref_decay;
 
   template<class T>
-    using @\libglobal{type_identity_t}@    = type_identity<T>::type;
+    using @\libglobal{type_identity_t}@    = @\libglobalref{type_identity}@<T>::type;
   template<class T>
-    using @\libglobal{remove_cvref_t}@     = remove_cvref<T>::type;
+    using @\libglobal{remove_cvref_t}@     = @\libglobalref{remove_cvref}@<T>::type;
   template<class T>
-    using @\libglobal{decay_t}@            = decay<T>::type;
+    using @\libglobal{decay_t}@            = @\libglobalref{decay}@<T>::type;
   template<bool B, class T = void>
-    using @\libglobal{enable_if_t}@        = enable_if<B, T>::type;
+    using @\libglobal{enable_if_t}@        = @\libglobalref{enable_if}@<B, T>::type;
   template<bool B, class T, class F>
-    using @\libglobal{conditional_t}@      = conditional<B, T, F>::type;
+    using @\libglobal{conditional_t}@      = @\libglobalref{conditional}@<B, T, F>::type;
   template<class... T>
-    using @\libglobal{common_type_t}@      = common_type<T...>::type;
+    using @\libglobal{common_type_t}@      = @\libglobalref{common_type}@<T...>::type;
   template<class... T>
-    using @\libglobal{common_reference_t}@ = common_reference<T...>::type;
+    using @\libglobal{common_reference_t}@ = @\libglobalref{common_reference}@<T...>::type;
   template<class T>
-    using @\libglobal{underlying_type_t}@  = underlying_type<T>::type;
+    using @\libglobal{underlying_type_t}@  = @\libglobalref{underlying_type}@<T>::type;
   template<class Fn, class... ArgTypes>
-    using @\libglobal{invoke_result_t}@    = invoke_result<Fn, ArgTypes...>::type;
+    using @\libglobal{invoke_result_t}@    = @\libglobalref{invoke_result}@<Fn, ArgTypes...>::type;
   template<class Fn, class Tuple>
-    using @\libglobal{apply_result_t}@     = apply_result<Fn, Tuple>::type;
+    using @\libglobal{apply_result_t}@     = @\libglobalref{apply_result}@<Fn, Tuple>::type;
   template<class T>
-    using @\libglobal{unwrap_reference_t}@ = unwrap_reference<T>::type;
+    using @\libglobal{unwrap_reference_t}@ = @\libglobalref{unwrap_reference}@<T>::type;
   template<class T>
-    using @\libglobal{unwrap_ref_decay_t}@ = unwrap_ref_decay<T>::type;
+    using @\libglobal{unwrap_ref_decay_t}@ = @\libglobalref{unwrap_ref_decay}@<T>::type;
   template<class...>
     using @\libglobal{void_t}@             = void;
 
@@ -429,185 +429,185 @@ namespace std {
 
   // \ref{meta.unary.cat}, primary type categories
   template<class T>
-    constexpr bool @\libglobal{is_void_v}@ = is_void<T>::value;
+    constexpr bool @\libglobal{is_void_v}@ = @\libglobalref{is_void}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_null_pointer_v}@ = is_null_pointer<T>::value;
+    constexpr bool @\libglobal{is_null_pointer_v}@ = @\libglobalref{is_null_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_integral_v}@ = is_integral<T>::value;
+    constexpr bool @\libglobal{is_integral_v}@ = @\libglobalref{is_integral}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_floating_point_v}@ = is_floating_point<T>::value;
+    constexpr bool @\libglobal{is_floating_point_v}@ = @\libglobalref{is_floating_point}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_array_v}@ = is_array<T>::value;
+    constexpr bool @\libglobal{is_array_v}@ = @\libglobalref{is_array}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_pointer_v}@ = is_pointer<T>::value;
+    constexpr bool @\libglobal{is_pointer_v}@ = @\libglobalref{is_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_lvalue_reference_v}@ = is_lvalue_reference<T>::value;
+    constexpr bool @\libglobal{is_lvalue_reference_v}@ = @\libglobalref{is_lvalue_reference}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_rvalue_reference_v}@ = is_rvalue_reference<T>::value;
+    constexpr bool @\libglobal{is_rvalue_reference_v}@ = @\libglobalref{is_rvalue_reference}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_member_object_pointer_v}@ = is_member_object_pointer<T>::value;
+    constexpr bool @\libglobal{is_member_object_pointer_v}@ = @\libglobalref{is_member_object_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_member_function_pointer_v}@ = is_member_function_pointer<T>::value;
+    constexpr bool @\libglobal{is_member_function_pointer_v}@ = @\libglobalref{is_member_function_pointer}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_enum_v}@ = is_enum<T>::value;
+    constexpr bool @\libglobal{is_enum_v}@ = @\libglobalref{is_enum}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_union_v}@ = is_union<T>::value;
+    constexpr bool @\libglobal{is_union_v}@ = @\libglobalref{is_union}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_class_v}@ = is_class<T>::value;
+    constexpr bool @\libglobal{is_class_v}@ = @\libglobalref{is_class}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_function_v}@ = is_function<T>::value;
+    constexpr bool @\libglobal{is_function_v}@ = @\libglobalref{is_function}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_reflection_v}@ = is_reflection<T>::value;
+    constexpr bool @\libglobal{is_reflection_v}@ = @\libglobalref{is_reflection}@<T>::value;
 
   // \ref{meta.unary.comp}, composite type categories
   template<class T>
-    constexpr bool @\libglobal{is_reference_v}@ = is_reference<T>::value;
+    constexpr bool @\libglobal{is_reference_v}@ = @\libglobalref{is_reference}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_arithmetic_v}@ = is_arithmetic<T>::value;
+    constexpr bool @\libglobal{is_arithmetic_v}@ = @\libglobalref{is_arithmetic}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_fundamental_v}@ = is_fundamental<T>::value;
+    constexpr bool @\libglobal{is_fundamental_v}@ = @\libglobalref{is_fundamental}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_object_v}@ = is_object<T>::value;
+    constexpr bool @\libglobal{is_object_v}@ = @\libglobalref{is_object}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_scalar_v}@ = is_scalar<T>::value;
+    constexpr bool @\libglobal{is_scalar_v}@ = @\libglobalref{is_scalar}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_compound_v}@ = is_compound<T>::value;
+    constexpr bool @\libglobal{is_compound_v}@ = @\libglobalref{is_compound}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_member_pointer_v}@ = is_member_pointer<T>::value;
+    constexpr bool @\libglobal{is_member_pointer_v}@ = @\libglobalref{is_member_pointer}@<T>::value;
 
   // \ref{meta.unary.prop}, type properties
   template<class T>
-    constexpr bool @\libglobal{is_const_v}@ = is_const<T>::value;
+    constexpr bool @\libglobal{is_const_v}@ = @\libglobalref{is_const}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_volatile_v}@ = is_volatile<T>::value;
+    constexpr bool @\libglobal{is_volatile_v}@ = @\libglobalref{is_volatile}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_trivially_copyable_v}@ = is_trivially_copyable<T>::value;
+    constexpr bool @\libglobal{is_trivially_copyable_v}@ = @\libglobalref{is_trivially_copyable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_standard_layout_v}@ = is_standard_layout<T>::value;
+    constexpr bool @\libglobal{is_standard_layout_v}@ = @\libglobalref{is_standard_layout}@<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_empty_v}@ = is_empty<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_polymorphic_v}@ = is_polymorphic<T>::value;
+    constexpr bool @\libglobal{is_polymorphic_v}@ = @\libglobalref{is_polymorphic}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_abstract_v}@ = is_abstract<T>::value;
+    constexpr bool @\libglobal{is_abstract_v}@ = @\libglobalref{is_abstract}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_final_v}@ = is_final<T>::value;
+    constexpr bool @\libglobal{is_final_v}@ = @\libglobalref{is_final}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_aggregate_v}@ = is_aggregate<T>::value;
+    constexpr bool @\libglobal{is_aggregate_v}@ = @\libglobalref{is_aggregate}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_structural_v}@ = is_structural<T>::value;
+    constexpr bool @\libglobal{is_structural_v}@ = @\libglobalref{is_structural}@<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_signed_v}@ = is_signed<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_unsigned_v}@ = is_unsigned<T>::value;
+    constexpr bool @\libglobal{is_unsigned_v}@ = @\libglobalref{is_unsigned}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_bounded_array_v}@ = is_bounded_array<T>::value;
+    constexpr bool @\libglobal{is_bounded_array_v}@ = @\libglobalref{is_bounded_array}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_unbounded_array_v}@ = is_unbounded_array<T>::value;
+    constexpr bool @\libglobal{is_unbounded_array_v}@ = @\libglobalref{is_unbounded_array}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_scoped_enum_v}@ = is_scoped_enum<T>::value;
+    constexpr bool @\libglobal{is_scoped_enum_v}@ = @\libglobalref{is_scoped_enum}@<T>::value;
   template<class T, class... Args>
-    constexpr bool @\libglobal{is_constructible_v}@ = is_constructible<T, Args...>::value;
+    constexpr bool @\libglobal{is_constructible_v}@ = @\libglobalref{is_constructible}@<T, Args...>::value;
   template<class T>
-    constexpr bool @\libglobal{is_default_constructible_v}@ = is_default_constructible<T>::value;
+    constexpr bool @\libglobal{is_default_constructible_v}@ = @\libglobalref{is_default_constructible}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_copy_constructible_v}@ = is_copy_constructible<T>::value;
+    constexpr bool @\libglobal{is_copy_constructible_v}@ = @\libglobalref{is_copy_constructible}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_move_constructible_v}@ = is_move_constructible<T>::value;
+    constexpr bool @\libglobal{is_move_constructible_v}@ = @\libglobalref{is_move_constructible}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_assignable_v}@ = is_assignable<T, U>::value;
+    constexpr bool @\libglobal{is_assignable_v}@ = @\libglobalref{is_assignable}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_copy_assignable_v}@ = is_copy_assignable<T>::value;
+    constexpr bool @\libglobal{is_copy_assignable_v}@ = @\libglobalref{is_copy_assignable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_move_assignable_v}@ = is_move_assignable<T>::value;
+    constexpr bool @\libglobal{is_move_assignable_v}@ = @\libglobalref{is_move_assignable}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_swappable_with_v}@ = is_swappable_with<T, U>::value;
+    constexpr bool @\libglobal{is_swappable_with_v}@ = @\libglobalref{is_swappable_with}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_swappable_v}@ = is_swappable<T>::value;
+    constexpr bool @\libglobal{is_swappable_v}@ = @\libglobalref{is_swappable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_destructible_v}@ = is_destructible<T>::value;
+    constexpr bool @\libglobal{is_destructible_v}@ = @\libglobalref{is_destructible}@<T>::value;
   template<class T, class... Args>
     constexpr bool @\libglobal{is_trivially_constructible_v}@ = is_trivially_constructible<T, Args...>::value;
   template<class T>
     constexpr bool @\libglobal{is_trivially_default_constructible_v}@
-      = is_trivially_default_constructible<T>::value;
+      = @\libglobalref{is_trivially_default_constructible}@<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_trivially_copy_constructible_v}@ = is_trivially_copy_constructible<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_trivially_move_constructible_v}@ = is_trivially_move_constructible<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_trivially_assignable_v}@ = is_trivially_assignable<T, U>::value;
+    constexpr bool @\libglobal{is_trivially_assignable_v}@ = @\libglobalref{is_trivially_assignable}@<T, U>::value;
   template<class T>
     constexpr bool @\libglobal{is_trivially_copy_assignable_v}@ = is_trivially_copy_assignable<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_trivially_move_assignable_v}@ = is_trivially_move_assignable<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_trivially_destructible_v}@ = is_trivially_destructible<T>::value;
+    constexpr bool @\libglobal{is_trivially_destructible_v}@ = @\libglobalref{is_trivially_destructible}@<T>::value;
   template<class T, class... Args>
     constexpr bool @\libglobal{is_nothrow_constructible_v}@ = is_nothrow_constructible<T, Args...>::value;
   template<class T>
     constexpr bool @\libglobal{is_nothrow_default_constructible_v}@
-      = is_nothrow_default_constructible<T>::value;
+      = @\libglobalref{is_nothrow_default_constructible}@<T>::value;
   template<class T>
     constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value;
   template<class T>
     constexpr bool @\libglobal{is_nothrow_move_constructible_v}@ = is_nothrow_move_constructible<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_nothrow_assignable_v}@ = is_nothrow_assignable<T, U>::value;
+    constexpr bool @\libglobal{is_nothrow_assignable_v}@ = @\libglobalref{is_nothrow_assignable}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = is_nothrow_copy_assignable<T>::value;
+    constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = @\libglobalref{is_nothrow_copy_assignable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = is_nothrow_move_assignable<T>::value;
+    constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = @\libglobalref{is_nothrow_move_assignable}@<T>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = is_nothrow_swappable_with<T, U>::value;
+    constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = @\libglobalref{is_nothrow_swappable_with}@<T, U>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_swappable_v}@ = is_nothrow_swappable<T>::value;
+    constexpr bool @\libglobal{is_nothrow_swappable_v}@ = @\libglobalref{is_nothrow_swappable}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_nothrow_destructible_v}@ = is_nothrow_destructible<T>::value;
+    constexpr bool @\libglobal{is_nothrow_destructible_v}@ = @\libglobalref{is_nothrow_destructible}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{is_implicit_lifetime_v}@ = is_implicit_lifetime<T>::value;
+    constexpr bool @\libglobal{is_implicit_lifetime_v}@ = @\libglobalref{is_implicit_lifetime}@<T>::value;
   template<class T>
-    constexpr bool @\libglobal{has_virtual_destructor_v}@ = has_virtual_destructor<T>::value;
+    constexpr bool @\libglobal{has_virtual_destructor_v}@ = @\libglobalref{has_virtual_destructor}@<T>::value;
   template<class T>
     constexpr bool @\libglobal{has_unique_object_representations_v}@
-      = has_unique_object_representations<T>::value;
+      = @\libglobalref{has_unique_object_representations}@<T>::value;
   template<class T, class U>
     constexpr bool @\libglobal{reference_constructs_from_temporary_v}@
-      = reference_constructs_from_temporary<T, U>::value;
+      = @\libglobalref{reference_constructs_from_temporary}@<T, U>::value;
   template<class T, class U>
     constexpr bool @\libglobal{reference_converts_from_temporary_v}@
-      = reference_converts_from_temporary<T, U>::value;
+      = @\libglobalref{reference_converts_from_temporary}@<T, U>::value;
 
   // \ref{meta.unary.prop.query}, type property queries
   template<class T>
-    constexpr size_t @\libglobal{alignment_of_v}@ = alignment_of<T>::value;
+    constexpr size_t @\libglobal{alignment_of_v}@ = @\libglobalref{alignment_of}@<T>::value;
   template<class T>
-    constexpr size_t @\libglobal{rank_v}@ = rank<T>::value;
+    constexpr size_t @\libglobal{rank_v}@ = @\libglobalref{rank}@<T>::value;
   template<class T, unsigned I = 0>
-    constexpr size_t @\libglobal{extent_v}@ = extent<T, I>::value;
+    constexpr size_t @\libglobal{extent_v}@ = @\libglobalref{extent}@<T, I>::value;
 
   // \ref{meta.rel}, type relations
   template<class T, class U>
-    constexpr bool @\libglobal{is_same_v}@ = is_same<T, U>::value;
+    constexpr bool @\libglobal{is_same_v}@ = @\libglobalref{is_same}@<T, U>::value;
   template<class Base, class Derived>
-    constexpr bool @\libglobal{is_base_of_v}@ = is_base_of<Base, Derived>::value;
+    constexpr bool @\libglobal{is_base_of_v}@ = @\libglobalref{is_base_of}@<Base, Derived>::value;
   template<class Base, class Derived>
-    constexpr bool @\libglobal{is_virtual_base_of_v}@ = is_virtual_base_of<Base, Derived>::value;
+    constexpr bool @\libglobal{is_virtual_base_of_v}@ = @\libglobalref{is_virtual_base_of}@<Base, Derived>::value;
   template<class From, class To>
-    constexpr bool @\libglobal{is_convertible_v}@ = is_convertible<From, To>::value;
+    constexpr bool @\libglobal{is_convertible_v}@ = @\libglobalref{is_convertible}@<From, To>::value;
   template<class From, class To>
-    constexpr bool @\libglobal{is_nothrow_convertible_v}@ = is_nothrow_convertible<From, To>::value;
+    constexpr bool @\libglobal{is_nothrow_convertible_v}@ = @\libglobalref{is_nothrow_convertible}@<From, To>::value;
   template<class T, class U>
-    constexpr bool @\libglobal{is_layout_compatible_v}@ = is_layout_compatible<T, U>::value;
+    constexpr bool @\libglobal{is_layout_compatible_v}@ = @\libglobalref{is_layout_compatible}@<T, U>::value;
   template<class Base, class Derived>
     constexpr bool @\libglobal{is_pointer_interconvertible_base_of_v}@
-      = is_pointer_interconvertible_base_of<Base, Derived>::value;
+      = @\libglobalref{is_pointer_interconvertible_base_of}@<Base, Derived>::value;
   template<class Fn, class... ArgTypes>
-    constexpr bool @\libglobal{is_invocable_v}@ = is_invocable<Fn, ArgTypes...>::value;
+    constexpr bool @\libglobal{is_invocable_v}@ = @\libglobalref{is_invocable}@<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
-    constexpr bool @\libglobal{is_invocable_r_v}@ = is_invocable_r<R, Fn, ArgTypes...>::value;
+    constexpr bool @\libglobal{is_invocable_r_v}@ = @\libglobalref{is_invocable_r}@<R, Fn, ArgTypes...>::value;
   template<class Fn, class... ArgTypes>
-    constexpr bool @\libglobal{is_nothrow_invocable_v}@ = is_nothrow_invocable<Fn, ArgTypes...>::value;
+    constexpr bool @\libglobal{is_nothrow_invocable_v}@ = @\libglobalref{is_nothrow_invocable}@<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
     constexpr bool @\libglobal{is_nothrow_invocable_r_v}@ = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
   template<class Fn, class Tuple>
@@ -617,11 +617,11 @@ namespace std {
 
   // \ref{meta.logical}, logical operator traits
   template<class... B>
-    constexpr bool @\libglobal{conjunction_v}@ = conjunction<B...>::value;
+    constexpr bool @\libglobal{conjunction_v}@ = @\libglobalref{conjunction}@<B...>::value;
   template<class... B>
-    constexpr bool @\libglobal{disjunction_v}@ = disjunction<B...>::value;
+    constexpr bool @\libglobal{disjunction_v}@ = @\libglobalref{disjunction}@<B...>::value;
   template<class B>
-    constexpr bool @\libglobal{negation_v}@ = negation<B>::value;
+    constexpr bool @\libglobal{negation_v}@ = @\libglobalref{negation}@<B>::value;
 
   // \ref{meta.member}, member relationships
   template<class S, class M>
@@ -674,7 +674,7 @@ properties of a type at compile time.
 
 \pnum
 Each of these templates shall be a
-\oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\oldconceptref{UnaryTypeTrait}
 with a base characteristic of
 \tcode{true_type} if the corresponding condition is \tcode{true}, otherwise
 \tcode{false_type}.
@@ -704,17 +704,14 @@ has a \tcode{value} member that evaluates to \tcode{true}.
 \topline
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endhead
-\indexlibraryglobal{is_void}%
 \tcode{template<class T>}\br
- \tcode{struct is_void;}                &
+ \tcode{struct \libglobal{is_void};}                &
 \tcode{T} is \keyword{void}       &   \\ \rowsep
-\indexlibraryglobal{is_null_pointer}%
 \tcode{template<class T>}\br
- \tcode{struct is_null_pointer;}                &
+ \tcode{struct \libglobal{is_null_pointer};}                &
 \tcode{T} is \tcode{nullptr_t}\iref{basic.fundamental}       &   \\ \rowsep
-\indexlibraryglobal{is_integral}%
 \tcode{template<class T>}\br
- \tcode{struct is_integral;}        &
+ \tcode{struct \libglobal{is_integral};}        &
 \tcode{T} is an integral type\iref{basic.fundamental}                 &   \\ \rowsep
 \indexlibraryglobal{is_floating_point}%
 \tcode{template<class T>}\br
@@ -929,9 +926,8 @@ A union is a class type that
 &
  If \tcode{T} is a class type, \tcode{T} shall be a complete type.                          \\ \rowsep
 
-\indexlibraryglobal{is_aggregate}%
 \tcode{template<class T>}\br
-  \tcode{struct is_aggregate;}           &
+  \tcode{struct \libglobal{is_aggregate};}           &
  \tcode{T} is an aggregate type\iref{dcl.init.aggr} &
  \tcode{T} shall be an array type, a complete type, or \cv~\keyword{void}.              \\ \rowsep
 
@@ -948,16 +944,14 @@ A union is a class type that
   \tcode{T(-1) < T(0)};
   otherwise, \tcode{false}   &   \\  \rowsep
 
-\indexlibraryglobal{is_unsigned}%
 \tcode{template<class T>}\br
-  \tcode{struct is_unsigned;}            &
+  \tcode{struct \libglobal{is_unsigned};}            &
   If \tcode{is_arithmetic_v<T>} is \tcode{true}, the same result as
   \tcode{T(0) < T(-1)};
   otherwise, \tcode{false}   &   \\  \rowsep
 
-\indexlibraryglobal{is_bounded_array}%
 \tcode{template<class T>}\br
-  \tcode{struct is_bounded_array;}       &
+  \tcode{struct \libglobal{is_bounded_array};}       &
   \tcode{T} is an array type of known bound\iref{dcl.array}
                              &   \\  \rowsep
 
@@ -1457,7 +1451,7 @@ may be used to query properties of types at compile time.
 \end{libreqtab2a}
 
 \pnum
-Each of these templates shall be a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts} with a
+Each of these templates shall be a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts} with a
 base characteristic of \tcode{integral_constant<size_t, Value>}.
 
 \pnum
@@ -1493,7 +1487,7 @@ may be used to query relationships between types at compile time.
 
 \pnum
 Each of these templates shall be a
-\oldconcept{BinaryTypeTrait}\iref{meta.rqmts}
+\oldconceptref{BinaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of
 \tcode{true_type} if the corresponding condition is true, otherwise
 \tcode{false_type}.
@@ -1514,7 +1508,7 @@ Let \tcode{\placeholdernc{ELEMS-OF}(T)} be the parameter pack
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endhead
 \tcode{template<class T, class U>}\br
- \tcode{struct is_same;}                    &
+ \tcode{struct \libglobal{is_same};}                    &
  \tcode{T} and \tcode{U} name the same type with the same cv-qualifications                            &   \\ \rowsep
 
 \indexlibraryglobal{is_base_of}%
@@ -1718,7 +1712,7 @@ type to another following some predefined rule.
 
 \pnum
 Each of the templates in \ref{meta.trans} shall be a
-\oldconcept{TransformationTrait}\iref{meta.rqmts}.
+\oldconceptref{TransformationTrait}\iref{meta.rqmts}.
 
 \rSec3[meta.trans.cv]{Const-volatile modifications}
 
@@ -2005,16 +1999,16 @@ perform other modifications of a type.
 \tcode{template<class T>\br struct \libglobal{remove_cvref};}
  &
  The member typedef \tcode{type} denotes
- \tcode{remove_cv_t<remove_reference_t<T>>}.
+ \tcode{\libglobalref{remove_cv_t}<\libglobalref{remove_reference_t}<T>>}.
  \\ \rowsep
 
 \tcode{template<class T>\br struct \libglobal{decay};}
  &
- Let \tcode{U} be \tcode{remove_reference_t<T>}. If \tcode{is_array_v<U>} is
+ Let \tcode{U} be \tcode{\libglobalref{remove_reference_t}<T>}. If \tcode{\libglobalref{is_array_v}<U>} is
  \tcode{true}, the member typedef \tcode{type} denotes
- \tcode{remove_extent_t<U>*}. If \tcode{is_function_v<U>} is \tcode{true},
- the member typedef \tcode{type} denotes \tcode{add_pointer_t<U>}. Otherwise
- the member typedef \tcode{type} denotes \tcode{remove_cv_t<U>}.
+ \tcode{\libglobalref{remove_extent_t}<U>*}. If \tcode{\libglobalref{is_function_v}<U>} is \tcode{true},
+ the member typedef \tcode{type} denotes \tcode{\libglobalref{add_pointer_t}<U>}. Otherwise
+ the member typedef \tcode{type} denotes \tcode{\libglobalref{remove_cv_t}<U>}.
 \begin{tailnote}
 This behavior is similar to the lvalue-to-rvalue\iref{conv.lval},
 array-to-pointer\iref{conv.array}, and function-to-pointer\iref{conv.func}
@@ -2120,7 +2114,7 @@ argument passing.
 \tcode{template<class T>} \tcode{struct \libglobal{unwrap_reference};}
  &
  If \tcode{T} is
- a specialization \tcode{reference_wrapper<X>} for some type \tcode{X},
+ a specialization \tcode{\libglobalref{reference_wrapper}<X>} for some type \tcode{X},
  the member typedef \tcode{type} of \tcode{unwrap_reference<T>}
  denotes \tcode{X\&},
  otherwise \tcode{type} denotes \tcode{T}. \\ \rowsep
@@ -2128,7 +2122,7 @@ argument passing.
 \tcode{template<class T>} \tcode{\libglobal{unwrap_ref_decay};}
  &
  The member typedef \tcode{type} of \tcode{unwrap_ref_decay<T>}
- denotes the type \tcode{unwrap_reference_t<decay_t<T>>}.\\
+ denotes the type \tcode{\libglobalref{unwrap_reference_t}<\libglobalref{decay_t}<T>>}.\\
 \end{libreqtab2a}
 
 \pnum
@@ -2146,7 +2140,7 @@ when the header \tcode{<func\-tional>}\iref{functional.syn} is included.
 Let:
 \begin{itemize}
 \item \tcode{\placeholdernc{CREF}(A)} be
-  \tcode{add_lvalue_reference_t<const remove_reference_t<A>{}>},
+  \tcode{\libglobalref{add_lvalue_reference_t}<const \libglobalref{remove_reference_t}<A>{}>},
 \item \tcode{\placeholdernc{XREF}(A)} denote a unary alias template \tcode{T}
   such that \tcode{T<U>} denotes the same type as \tcode{U} with the addition
   of \tcode{A}'s cv and reference qualifiers, for a non-reference cv-unqualified
@@ -2171,15 +2165,15 @@ let \tcode{\placeholdernc{COMMON-\brk{}REF}(A, B)} be:
     \placeholdernc{COPYCV}(\brk{}Y, X) \&)} if that type exists
   and is a reference type.
 \item Otherwise, let \tcode{C} be
-  \tcode{remove_reference_t<\placeholdernc{COMMON-REF}(X\&, Y\&)>\&\&}.
+  \tcode{\libglobalref{remove_reference_t}<\placeholdernc{COMMON-REF}(X\&, Y\&)>\&\&}.
   If \tcode{A} and \tcode{B} are both rvalue reference types,
   \tcode{C} is well-formed, and
-  \tcode{is_convertible_v<A, C> \&\& is_convertible_v<B, C>} is \tcode{true},
+  \tcode{\libglobalref{is_convertible_v}<A, C> \&\& \libglobalref{is_convertible_v}<B, C>} is \tcode{true},
   then \tcode{\placeholdernc{COMMON-REF}(A, B)} is \tcode{C}.
 \item Otherwise, let \tcode{D} be
   \tcode{\placeholdernc{COMMON-REF}(const X\&, Y\&)}. If \tcode{A} is an rvalue
   reference and \tcode{B} is an lvalue reference and \tcode{D} is
-  well-formed and \tcode{is_convertible_v<A, D>} is
+  well-formed and \tcode{\libglobalref{is_convertible_v}<A, D>} is
   \tcode{true}, then \tcode{\placeholdernc{COMMON-REF}(A, B)} is \tcode{D}.
 \item Otherwise, if \tcode{A} is an lvalue reference and \tcode{B}
   is an rvalue reference, then \tcode{\placeholdernc{COMMON-REF}(A, B)} is
@@ -2478,7 +2472,7 @@ template<class B> struct negation : @\seebelow@ { };
 The class template \tcode{negation}
 forms the logical negation of its template type argument.
 The type \tcode{negation<B>}
-is a \oldconcept{UnaryTypeTrait} with a base characteristic of \tcode{bool_constant<!bool(B::\brk{}value)>}.
+is a \oldconceptref{UnaryTypeTrait} with a base characteristic of \tcode{bool_constant<!bool(B::\brk{}value)>}.
 \end{itemdescr}
 
 \rSec2[meta.member]{Member relationships}
diff --git a/source/numerics.tex b/source/numerics.tex
index c79aa0d9..bf16ade5 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -41,10 +41,10 @@ components are parameterized by the type of information they contain and manipul
 A \Cpp{} program shall instantiate these components only with a numeric type.
 A \defnadj{numeric}{type} is a cv-unqualified object type \tcode{T}
 that meets the
-\oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable}, and
-\oldconcept{Destructible}
+\oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable}, and
+\oldconceptref{Destructible}
 requirements\iref{utility.arg.requirements}.
 \begin{footnote}
 In other words, value types.
@@ -2023,8 +2023,8 @@ according to \ref{strings} and \ref{input.output}.
 
 \pnum
 \tcode{E} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 These operations shall each be of complexity
 no worse than \bigoh{\text{size of state}}.
 
@@ -2452,8 +2452,8 @@ according to \ref{strings} and \ref{input.output}.
 
 \pnum
 \tcode{D} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 
 \pnum
 The sequence of numbers
@@ -2484,10 +2484,10 @@ for convenience of exposition only.
 
 \pnum
 \tcode{P} shall meet the
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}),
 and
-\oldconcept{Equality\-Comp\-arable} (\tref{cpp17.equalitycomparable}) requirements.
+\oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 For each of the constructors of \tcode{D}
@@ -4231,7 +4231,7 @@ template<class InputIterator>
 \pnum
 \expects
   \tcode{InputIterator} meets the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
 
 \pnum
 \effects
@@ -4258,7 +4258,7 @@ template<class RandomAccessIterator>
 \pnum
 \expects
   \tcode{RandomAccessIterator} meets the
-  \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}
+  \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}
   and the requirements of a mutable iterator.
 
 \pnum
@@ -4371,7 +4371,7 @@ template<class OutputIterator>
 \pnum
 \expects
   \tcode{OutputIterator} meets the
-  \oldconcept{OutputIterator} requirements\iref{output.iterators}.
+  \oldconceptref{OutputIterator} requirements\iref{output.iterators}.
 
 \pnum
 \effects
@@ -6366,7 +6366,7 @@ double>} is \tcode{true}.
 \pnum
 \expects
   \tcode{InputIterator} meets the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
  If \tcode{firstW == lastW},
  let $n = 1$ and $w_0 = 1$.
  Otherwise,
@@ -6564,7 +6564,7 @@ are \tcode{true}.
 \expects
   \tcode{InputIteratorB} and \tcode{InputIteratorW}
    each meet the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
  If \tcode{firstB == lastB}
  or \tcode{++firstB == lastB},
  let $n = 1$,
@@ -6799,7 +6799,7 @@ are \tcode{true}.
 \expects
   \tcode{InputIteratorB} and \tcode{InputIteratorW}
    each meet the
-  \oldconcept{InputIterator} requirements\iref{input.iterators}.
+  \oldconceptref{InputIterator} requirements\iref{input.iterators}.
  If \tcode{firstB == lastB}
  or \tcode{++firstB == lastB},
  let $n = 1$,
diff --git a/source/strings.tex b/source/strings.tex
index 87703e3e..ca7a2e67 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -238,10 +238,10 @@ using state_type = @\seebelow@;
 \pnum
 \expects
 \tcode{state_type} meets the
-\oldconcept{Destructible} (\tref{cpp17.destructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}), and
-\oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}) requirements.
+\oldconceptref{Destructible} (\tref{cpp17.destructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}), and
+\oldconceptref{DefaultConstructible} (\tref{cpp17.defaultconstructible}) requirements.
 \end{itemdescr}
 
 \rSec2[char.traits.specializations]{\tcode{char_traits} specializations}
@@ -935,7 +935,7 @@ using const_iterator = @\impdefx{type of \tcode{basic_string_view::const_iterato
 \pnum
 A type that meets the requirements
 of a constant
-\oldconcept{RandomAccessIterator}\iref{random.access.iterators},
+\oldconceptref{RandomAccessIterator}\iref{random.access.iterators},
 models \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous}, and
 meets the constexpr iterator requirements\iref{iterator.requirements.general},
 whose \tcode{value_type} is the template parameter \tcode{charT}.
diff --git a/source/support.tex b/source/support.tex
index 0a30bcb5..9d3be7f0 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -4114,7 +4114,7 @@ The type \tcode{exception_ptr} can be used to refer to an exception object.
 
 \pnum
 \tcode{exception_ptr} meets the requirements of
-\oldconcept{NullablePointer} (\tref{cpp17.nullablepointer}).
+\oldconceptref{NullablePointer} (\tref{cpp17.nullablepointer}).
 
 \pnum
 Two non-null values of type \tcode{exception_ptr} are equivalent and compare equal if and
@@ -4338,7 +4338,7 @@ Let \tcode{U} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{U} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{U} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \throws
diff --git a/source/threads.tex b/source/threads.tex
index 9ea022ab..f301c230 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -41,7 +41,7 @@ yields \tcode{true} if the corresponding test condition is satisfied, and
 \tcode{false} otherwise.
 If a template parameter is named \tcode{Clock},
 the corresponding template argument shall be a type \tcode{C}
-that meets the \oldconcept{Clock} requirements\iref{time.clock.req};
+that meets the \oldconceptref{Clock} requirements\iref{time.clock.req};
 the program is ill-formed if \tcode{is_clock_v<C>} is \tcode{false}.
 
 \rSec2[thread.req.exception]{Exceptions}
@@ -156,7 +156,7 @@ and hardware. The finest resolution provided by an implementation is called the
 
 \pnum
 Implementation-provided clocks that are used for these functions meet the
-\oldconcept{TrivialClock} requirements\iref{time.clock.req}.
+\oldconceptref{TrivialClock} requirements\iref{time.clock.req}.
 
 \pnum
 A function that takes an argument which specifies a timeout will throw if,
@@ -195,10 +195,10 @@ The standard library templates \tcode{unique_lock}\iref{thread.lock.unique},
 \tcode{lock_guard}\iref{thread.lock.guard}, \tcode{lock},
 \tcode{try_lock}\iref{thread.lock.algorithm}, and
 \tcode{condition_variable_any}\iref{thread.condition.condvarany} all operate on user-supplied
-lockable objects. The \oldconcept{BasicLockable} requirements, the \oldconcept{Lockable} requirements,
-the \oldconcept{TimedLockable} requirements,
-the \oldconcept{SharedLockable} requirements, and
-the \oldconcept{SharedTimedLock\-able} requirements
+lockable objects. The \oldconceptref{BasicLockable} requirements, the \oldconceptref{Lockable} requirements,
+the \oldconceptref{TimedLockable} requirements,
+the \oldconceptref{SharedLockable} requirements, and
+the \oldconceptref{SharedTimedLockable} requirements
 list the requirements imposed by these library types
 in order to acquire or release ownership of a \tcode{lock} by a given execution agent.
 \begin{note}
@@ -266,7 +266,7 @@ Nothing.
 \rSec3[thread.req.lockable.req]{\oldconcept{Lockable} requirements}
 
 \pnum
-A type \tcode{L} meets the \defnoldconcept{Lockable} requirements if it meets the \oldconcept{BasicLockable}
+A type \tcode{L} meets the \defnoldconcept{Lockable} requirements if it meets the \oldconceptref{BasicLockable}
 requirements and the following expressions are well-formed and have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L}).
 
@@ -291,7 +291,7 @@ exception is thrown then a lock shall not have been acquired for the current exe
 \rSec3[thread.req.lockable.timed]{\oldconcept{TimedLockable} requirements}
 
 \pnum
-A type \tcode{L} meets the \defnoldconcept{TimedLockable} requirements if it meets the \oldconcept{Lockable}
+A type \tcode{L} meets the \defnoldconcept{TimedLockable} requirements if it meets the \oldconceptref{Lockable}
 requirements and the following expressions are well-formed and have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L}, \tcode{rel_time} denotes a value of a
 specialization of \tcode{duration}\iref{time.duration}, and \tcode{abs_time} denotes a value
@@ -397,7 +397,7 @@ Nothing.
 
 \pnum
 A type \tcode{L} meets the \defnoldconcept{SharedTimedLockable} requirements if
-it meets the \oldconcept{SharedLockable} requirements, and
+it meets the \oldconceptref{SharedLockable} requirements, and
 the following expressions are well-formed, have type \tcode{bool}, and
 have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L},
@@ -4724,7 +4724,7 @@ namespace std {
 \indexlibraryglobal{atomic}%
 \pnum
 The template argument for \tcode{T} shall meet the
-\oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} requirements.
+\oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements.
 The program is ill-formed if any of
 \begin{itemize}
 \item \tcode{is_trivially_copyable_v<T>},
@@ -7575,11 +7575,11 @@ The \defn{mutex types} are the standard library types \tcode{mutex},
 They meet the requirements set out in \ref{thread.mutex.requirements.mutex}.
 In this description, \tcode{m} denotes an object of a mutex type.
 \begin{note}
-The mutex types meet the \oldconcept{Lockable} requirements\iref{thread.req.lockable.req}.
+The mutex types meet the \oldconceptref{Lockable} requirements\iref{thread.req.lockable.req}.
 \end{note}
 
 \pnum
-The mutex types meet \oldconcept{DefaultConstructible} and \oldconcept{Destructible}.
+The mutex types meet \oldconceptref{DefaultConstructible} and \oldconceptref{Destructible}.
 If initialization of an object of a mutex type fails,
 an exception of type \tcode{system_error} is thrown.
 The mutex types are neither copyable nor movable.
@@ -7848,7 +7848,7 @@ specialization of \tcode{duration}\iref{time.duration}, and \tcode{abs_time} den
 object of a
 specialization of \tcode{time_point}\iref{time.point}.
 \begin{note}
-The timed mutex types meet the \oldconcept{TimedLockable}
+The timed mutex types meet the \oldconceptref{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
 \end{note}
 
@@ -8060,7 +8060,7 @@ mutex types\iref{thread.mutex.requirements.mutex} and additionally
 meet the requirements set out below. In this description,
 \tcode{m} denotes an object of a shared mutex type.
 \begin{note}
-The shared mutex types meet the \oldconcept{SharedLockable}
+The shared mutex types meet the \oldconceptref{SharedLockable}
 requirements\iref{thread.req.lockable.shared}.
 \end{note}
 
@@ -8237,7 +8237,7 @@ meet the requirements set out below. In this description,
 \tcode{abs_time} denotes an object of a specialization of
 \tcode{time_point}\iref{time.point}.
 \begin{note}
-The shared timed mutex types meet the \oldconcept{SharedTimedLockable}
+The shared timed mutex types meet the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 \end{note}
 
@@ -8447,7 +8447,7 @@ within a scope. A \tcode{lock_guard} object maintains ownership of a lockable
 object throughout the \tcode{lock_guard} object's \deflink{lifetime}{basic.life}.
 The behavior of a program is undefined if the lockable object referenced by
 \exposid{pm} does not exist for the entire lifetime of the \tcode{lock_guard}
-object. The supplied \tcode{Mutex} type shall meet the \oldconcept{BasicLockable}
+object. The supplied \tcode{Mutex} type shall meet the \oldconceptref{BasicLockable}
 requirements\iref{thread.req.lockable.basic}.
 
 \indexlibraryctor{lock_guard}%
@@ -8526,12 +8526,12 @@ object.
 If \tcode{sizeof...(MutexTypes)} is one,
 let \tcode{Mutex} denote the sole type constituting the pack \tcode{MutexTypes}.
 \tcode{Mutex}
-shall meet the \oldconcept{BasicLockable} requirements\iref{thread.req.lockable.basic}.
+shall meet the \oldconceptref{BasicLockable} requirements\iref{thread.req.lockable.basic}.
 The member \grammarterm{typedef-name} \tcode{mutex_type}
 denotes the same type as \tcode{Mutex}.
 \item
 Otherwise, all types in the template parameter pack \tcode{MutexTypes}
-shall meet the \oldconcept{Lockable} requirements\iref{thread.req.lockable.req}
+shall meet the \oldconceptref{Lockable} requirements\iref{thread.req.lockable.req}
 and there is no member \tcode{mutex_type}.
 \end{itemize}
 
@@ -8646,17 +8646,17 @@ copyable but are movable. The behavior of a program is undefined if the containe
 \exposid{pm} is not null and the lockable object pointed
 to by \exposid{pm} does not exist for the entire remaining
 lifetime\iref{basic.life} of the \tcode{unique_lock} object. The supplied
-\tcode{Mutex} type shall meet the \oldconcept{BasicLockable}
+\tcode{Mutex} type shall meet the \oldconceptref{BasicLockable}
 requirements\iref{thread.req.lockable.basic}.
 
 \pnum
 \begin{note}
-\tcode{unique_lock<Mutex>} meets the \oldconcept{BasicLockable} requirements. If \tcode{Mutex}
-meets the \oldconcept{Lockable} requirements\iref{thread.req.lockable.req},
-\tcode{unique_lock<Mutex>} also meets the \oldconcept{Lockable} requirements;
+\tcode{unique_lock<Mutex>} meets the \oldconceptref{BasicLockable} requirements. If \tcode{Mutex}
+meets the \oldconceptref{Lockable} requirements\iref{thread.req.lockable.req},
+\tcode{unique_lock<Mutex>} also meets the \oldconceptref{Lockable} requirements;
 if \tcode{Mutex}
-meets the \oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed},
-\tcode{unique_lock<Mutex>} also meets the \oldconcept{TimedLockable} requirements.
+meets the \oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed},
+\tcode{unique_lock<Mutex>} also meets the \oldconceptref{TimedLockable} requirements.
 \end{note}
 
 \rSec4[thread.lock.unique.cons]{Constructors, destructor, and assignment}
@@ -8706,7 +8706,7 @@ unique_lock(mutex_type& m, try_to_lock_t);
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{Lockable}
+The supplied \tcode{Mutex} type meets the \oldconceptref{Lockable}
 requirements\iref{thread.req.lockable.req}.
 
 \pnum
@@ -8748,7 +8748,7 @@ template<class Clock, class Duration>
 \pnum
 \expects
 The supplied \tcode{Mutex} type meets the
-\oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed}.
+\oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed}.
 
 \pnum
 \effects
@@ -8770,7 +8770,7 @@ template<class Rep, class Period>
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed}.
+The supplied \tcode{Mutex} type meets the \oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed}.
 
 \pnum
 \effects
@@ -8857,7 +8857,7 @@ bool try_lock();
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} meets the \oldconcept{Lockable}
+The supplied \tcode{Mutex} meets the \oldconceptref{Lockable}
 requirements\iref{thread.req.lockable.req}.
 
 \pnum
@@ -8896,7 +8896,7 @@ template<class Clock, class Duration>
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{TimedLockable}
+The supplied \tcode{Mutex} type meets the \oldconceptref{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
 
 \pnum
@@ -8935,7 +8935,7 @@ template<class Rep, class Period>
 \begin{itemdescr}
 \pnum
 \expects
-The supplied \tcode{Mutex} type meets the \oldconcept{TimedLockable} requirements\iref{thread.req.lockable.timed}.
+The supplied \tcode{Mutex} type meets the \oldconceptref{TimedLockable} requirements\iref{thread.req.lockable.timed}.
 
 \pnum
 \effects
@@ -9128,16 +9128,16 @@ acquisition, to another \tcode{shared_lock} object. Objects of type
 is undefined if the contained pointer \exposid{pm} is not null and the lockable
 object pointed to by \exposid{pm} does not exist for the entire remaining
 lifetime\iref{basic.life} of the \tcode{shared_lock} object. The supplied
-\tcode{Mutex} type shall meet the \oldconcept{SharedLockable}
+\tcode{Mutex} type shall meet the \oldconceptref{SharedLockable}
 requirements\iref{thread.req.lockable.shared}.
 
 \pnum
 \begin{note}
-\tcode{shared_lock<Mutex>} meets the \oldconcept{Lockable}
+\tcode{shared_lock<Mutex>} meets the \oldconceptref{Lockable}
 requirements\iref{thread.req.lockable.req}.
-If \tcode{Mutex} meets the \oldconcept{Shared\-TimedLockable}
+If \tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed},
-\tcode{shared_lock<Mutex>} also meets the \oldconcept{TimedLockable}
+\tcode{shared_lock<Mutex>} also meets the \oldconceptref{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
 \end{note}
 
@@ -9222,7 +9222,7 @@ template<class Clock, class Duration>
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -9246,7 +9246,7 @@ template<class Rep, class Period>
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -9371,7 +9371,7 @@ template<class Clock, class Duration>
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -9411,7 +9411,7 @@ template<class Rep, class Period>
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{Mutex} meets the \oldconcept{SharedTimedLockable}
+\tcode{Mutex} meets the \oldconceptref{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
 
 \pnum
@@ -9550,7 +9550,7 @@ template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
 \begin{itemdescr}
 \pnum
 \expects
-Each template parameter type meets the \oldconcept{Lockable} requirements.
+Each template parameter type meets the \oldconceptref{Lockable} requirements.
 \begin{note}
 The
 \tcode{unique_lock} class template meets these requirements when suitably instantiated.
@@ -9579,7 +9579,7 @@ template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
 \begin{itemdescr}
 \pnum
 \expects
-Each template parameter type meets the \oldconcept{Lockable} requirements.
+Each template parameter type meets the \oldconceptref{Lockable} requirements.
 \begin{note}
 The
 \tcode{unique_lock} class template meets these requirements when suitably instantiated.
@@ -10258,7 +10258,7 @@ This can happen if the re-locking of the mutex throws an exception.
 \pnum
 In \ref{thread.condition.condvarany},
 template arguments for template parameters named \tcode{Lock}
-shall meet the \oldconcept{Basic\-Lockable}
+shall meet the \oldconceptref{BasicLockable}
 requirements\iref{thread.req.lockable.basic}.
 \begin{note}
 All of the standard
@@ -11195,24 +11195,24 @@ execute atomically.
 
 \pnum
 \tcode{CompletionFunction} shall meet the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+\oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 \tcode{is_nothrow_invocable_v<CompletionFunction\&>} shall be \tcode{true}.
 
 \pnum
 The default value of the \tcode{CompletionFunction} template parameter is
 an unspecified type, such that,
 in addition to satisfying the requirements of \tcode{CompletionFunction},
-it meets the \oldconcept{DefaultConstructible}
+it meets the \oldconceptref{DefaultConstructible}
 requirements (\tref{cpp17.defaultconstructible}) and
 \tcode{\exposid{completion}()} has no effects.
 
 \pnum
 \tcode{barrier::arrival_token} is an unspecified type,
 such that it meets the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}),
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+\oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible}),
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable}), and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 
 \indexlibrarymember{max}{barrier}%
 \begin{itemdecl}
@@ -11707,7 +11707,7 @@ namespace std {
 
 \pnum
 For the primary template, \tcode{R} shall be an object type that
-meets the \oldconcept{Destructible} requirements.
+meets the \oldconceptref{Destructible} requirements.
 
 \pnum
 The implementation provides the template \tcode{promise} and two specializations,
@@ -12039,7 +12039,7 @@ namespace std {
 
 \pnum
 For the primary template, \tcode{R} shall be an object type that
-meets the \oldconcept{Destructible} requirements.
+meets the \oldconceptref{Destructible} requirements.
 
 \pnum
 The implementation provides the template \tcode{future} and two specializations,
@@ -12345,7 +12345,7 @@ namespace std {
 
 \pnum
 For the primary template, \tcode{R} shall be an object type that
-meets the \oldconcept{Destructible} requirements.
+meets the \oldconceptref{Destructible} requirements.
 
 \pnum
 The implementation provides the template \tcode{shared_future} and two
@@ -13283,7 +13283,7 @@ the expression \tcode{d(ptr)} is valid.
 
 \pnum
 \tcode{D} shall meet the requirements for
-\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}.
+\oldconceptref{DefaultConstructible} and \oldconceptref{MoveAssignable}.
 
 \pnum
 If \tcode{D} is trivially copyable,
@@ -13341,7 +13341,7 @@ namespace std {
 
 \pnum
 This class meets the requirements of
-\oldconcept{Lockable}\iref{thread.req.lockable.req} and
+\oldconceptref{Lockable}\iref{thread.req.lockable.req} and
 provides regions of RCU protection.
 \begin{example}
 \begin{codeblock}
@@ -13489,8 +13489,8 @@ the expression \tcode{d(p)} is well-formed.
 
 \pnum
 \expects
-\tcode{D} meets the \oldconcept{MoveConstructible} and
-\oldconcept{Destructible} requirements.
+\tcode{D} meets the \oldconceptref{MoveConstructible} and
+\oldconceptref{Destructible} requirements.
 
 \pnum
 \effects
@@ -13684,7 +13684,7 @@ that adds specializations for \tcode{hazard_pointer_obj_base} is undefined.
 
 \pnum
 \tcode{D} shall meet the requirements for
-\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}.
+\oldconceptref{DefaultConstructible} and \oldconceptref{MoveAssignable}.
 
 \pnum
 \tcode{T} may be an incomplete type.
diff --git a/source/time.tex b/source/time.tex
index f75f6adb..9b9cdf63 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -1034,13 +1034,13 @@ SI definition is a measure of the quality of implementation.
 A type \tcode{TC} meets the \defnoldconcept{TrivialClock} requirements if
 \begin{itemize}
 \item
-\tcode{TC} meets the \oldconcept{Clock} requirements,
+\tcode{TC} meets the \oldconceptref{Clock} requirements,
 
 \item
 the types \tcode{TC::rep}, \tcode{TC::duration}, and \tcode{TC::time_point}
-meet the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) and
-\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable})
-and \oldconcept{Swappable}\iref{swappable.requirements}
+meet the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) and
+\oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable})
+and \oldconceptref{Swappable}\iref{swappable.requirements}
 requirements and the requirements of
 numeric types\iref{numeric.requirements},
 \begin{note}
@@ -1198,15 +1198,15 @@ template<class T> struct is_clock;
 \end{itemdecl}
 
 \pnum
-\tcode{is_clock} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\tcode{is_clock} is a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of \tcode{true_type}
-if \tcode{T} meets the \oldconcept{Clock} requirements\iref{time.clock.req},
+if \tcode{T} meets the \oldconceptref{Clock} requirements\iref{time.clock.req},
 otherwise \tcode{false_type}.
 For the purposes of the specification of this trait,
 the extent to which an implementation determines
-that a type cannot meet the \oldconcept{Clock} requirements is unspecified,
+that a type cannot meet the \oldconceptref{Clock} requirements is unspecified,
 except that as a minimum
-a type \tcode{T} shall not qualify as a \oldconcept{Clock}
+a type \tcode{T} shall not qualify as a \oldconceptref{Clock}
 unless it meets all of the following conditions:
 \begin{itemize}
 \item the \grammarterm{qualified-id}s
@@ -2634,7 +2634,7 @@ template<class ToDuration, class Clock, class Duration>
 
 \pnum
 The types defined in \ref{time.clock} meet the
-\oldconcept{TrivialClock}
+\oldconceptref{TrivialClock}
 requirements\iref{time.clock.req}
 unless otherwise specified.
 
@@ -2852,7 +2852,7 @@ which is \tcode{10'957 * 86'400s + 22s}. \\
 \end{example}
 
 \pnum
-\tcode{utc_clock} is not a \oldconcept{TrivialClock}
+\tcode{utc_clock} is not a \oldconceptref{TrivialClock}
 unless the implementation can guarantee that \tcode{utc_clock::now()}
 does not propagate an exception.
 \begin{note}
@@ -3071,7 +3071,7 @@ so 2000-01-01 00:00:00 UTC is equivalent to 2000-01-01 00:00:32 TAI
 (22s plus the initial 10s offset).
 
 \pnum
-\tcode{tai_clock} is not a \oldconcept{TrivialClock}
+\tcode{tai_clock} is not a \oldconceptref{TrivialClock}
 unless the implementation can guarantee that \tcode{tai_clock::now()}
 does not propagate an exception.
 \begin{note}
@@ -3233,7 +3233,7 @@ GPS is behind TAI by 19s due to the 10s offset between 1958 and 1970
 and the additional 9 leap seconds inserted between 1970 and 1980.
 
 \pnum
-\tcode{gps_clock} is not a \oldconcept{TrivialClock}
+\tcode{gps_clock} is not a \oldconceptref{TrivialClock}
 unless the implementation can guarantee that
 \tcode{gps_clock::now()} does not propagate an exception.
 \begin{note}
@@ -3370,7 +3370,7 @@ namespace std::chrono {
 
 \pnum
 \tcode{file_clock} is an alias for a type
-meeting the \oldconcept{TrivialClock} requirements\iref{time.clock.req}, and
+meeting the \oldconceptref{TrivialClock} requirements\iref{time.clock.req}, and
 using a signed arithmetic type for \tcode{file_clock::rep}.
 \tcode{file_clock} is used to create the \tcode{time_point} system
 used for \tcode{file_time_type}\iref{filesystems}.
@@ -3977,8 +3977,8 @@ It normally holds values in the range 1 to 31,
 but may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{day}'s unspecified internal storage.
-\tcode{day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{day} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
 and participates in basic arithmetic with \tcode{days} objects,
 which represent a difference between two \tcode{day} objects.
 
@@ -4270,8 +4270,8 @@ It normally holds values in the range 1 to 12,
 but may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{month}'s unspecified internal storage.
-\tcode{month} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{month} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
 and participates in basic arithmetic with \tcode{months} objects,
 which represent a difference between two \tcode{month} objects.
 
@@ -4580,8 +4580,8 @@ namespace std::chrono {
 It can represent values in the range \crange{min()}{max()}.
 It can be constructed with any \tcode{int} value,
 which will be subsequently truncated to fit into \tcode{year}'s unspecified internal storage.
-\tcode{year} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
+\tcode{year} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements,
 and participates in basic arithmetic with \tcode{years} objects,
 which represent a difference between two \tcode{year} objects.
 
@@ -4935,10 +4935,10 @@ corresponding to Sunday through Saturday, but
 it may hold non-negative values outside this range.
 It can be constructed with any \tcode{unsigned} value,
 which will be subsequently truncated to fit into \tcode{weekday}'s unspecified internal storage.
-\tcode{weekday} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{weekday} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 \begin{note}
 \tcode{weekday} is not
-\oldconcept{LessThanComparable}
+\oldconceptref{LessThanComparable}
 because there is no universal consensus on which day is the first day of the week.
 \tcode{weekday}'s arithmetic operations treat the days of the week as a circular range,
 with no beginning and no end.
@@ -5518,8 +5518,8 @@ namespace std::chrono {
 \pnum
 \tcode{month_day} represents a specific day of a specific month,
 but with an unspecified year.
-\tcode{month_day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{month_day} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{month_day} is a trivially copyable and standard-layout class type.
@@ -6019,8 +6019,8 @@ namespace std::chrono {
 \tcode{year_month} represents a specific month of a specific year,
 but with an unspecified day.
 \tcode{year_month} is a field-based time point with a resolution of \tcode{months}.
-\tcode{year_month} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{year_month} is a trivially copyable and standard-layout class type.
@@ -6375,8 +6375,8 @@ but not \tcode{days}-oriented arithmetic.
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month_day} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{year_month_day} is a trivially copyable and standard-layout class type.
@@ -6836,8 +6836,8 @@ but not \tcode{days}-oriented arithmetic.
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day_last} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
-and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
+\tcode{year_month_day_last} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconceptref{LessThanComparable} (\tref{cpp17.lessthancomparable}) requirements.
 
 \pnum
 \tcode{year_month_day_last} is a trivially copyable and standard-layout class type.
@@ -7207,7 +7207,7 @@ but not \tcode{days}-oriented arithmetic.
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{year_month_weekday} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 \tcode{year_month_weekday} is a trivially copyable and standard-layout class type.
@@ -7600,7 +7600,7 @@ but not \tcode{days}-oriented arithmetic.
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday_last} meets the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+\tcode{year_month_weekday_last} meets the \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 \tcode{year_month_weekday_last} is a trivially copyable and standard-layout class type.
@@ -8853,7 +8853,7 @@ The \tcode{tzdb_list} object contains a list of \tcode{tzdb} objects.
 
 \pnum
 \tcode{tzdb_list::const_iterator} is a constant iterator
-which meets the \oldconcept{ForwardIterator} requirements
+which meets the \oldconceptref{ForwardIterator} requirements
 and has a value type of \tcode{tzdb}.
 
 \indexlibrarymember{front}{tzdb_list}%
@@ -11577,7 +11577,7 @@ template<> struct hash<chrono::year_month_weekday_last>;
 The specializations are enabled\iref{unord.hash}.
 \begin{note}
 All the \tcode{hash<Key>} specializations listed above meet the
-\oldconcept{Hash} requirements, even when called on objects \tcode{k}
+\oldconceptref{Hash} requirements, even when called on objects \tcode{k}
 of type \tcode{Key} such that \tcode{k.ok()} is \tcode{false}.
 \end{note}
 \end{itemdescr}
diff --git a/source/utilities.tex b/source/utilities.tex
index 0287e368..bc5632a5 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -274,9 +274,9 @@ template<class T>
 Type
 \tcode{T}
 meets the
-\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible})
+\oldconceptref{MoveConstructible} (\tref{cpp17.moveconstructible})
 and
-\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable})
+\oldconceptref{MoveAssignable} (\tref{cpp17.moveassignable})
 requirements.
 
 \pnum
@@ -2431,7 +2431,7 @@ template<class Alloc, @\exposconcept{tuple-like}@ UTuple>
 \pnum
 \expects
 \tcode{Alloc} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \effects
@@ -3054,7 +3054,7 @@ template<class T> struct tuple_size;
 \pnum
 Except where specified otherwise,
 all specializations of \tcode{tuple_size} meet the
-\oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
+\oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
 base characteristic of \tcode{integral_constant<size_t, N>}
 for some \tcode{N}.
 \end{itemdescr}
@@ -3095,7 +3095,7 @@ template<class T> struct tuple_size<const T>;
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
 when treated as an \deflink{unevaluated operand}{expr.context}, then
-each specialization of the template meets the \oldconcept{Unary\-Type\-Trait} requirements\iref{meta.rqmts}
+each specialization of the template meets the \oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}
 with a base characteristic of
 \begin{codeblock}
 integral_constant<size_t, TS::value>
@@ -3133,7 +3133,7 @@ template<size_t I, class T> struct tuple_element<I, const T>;
 \begin{itemdescr}
 \pnum
 Let \tcode{TE} denote \tcode{tuple_element_t<I, T>} of the cv-unqualified type \tcode{T}. Then
-each specialization of the template meets the \oldconcept{TransformationTrait} requirements\iref{meta.rqmts}
+each specialization of the template meets the \oldconceptref{TransformationTrait} requirements\iref{meta.rqmts}
 with a member typedef \tcode{type} that names the type \tcode{const TE}.
 
 \pnum
@@ -3419,7 +3419,7 @@ template<class... Types, class Alloc>
 \pnum
 \expects
 \tcode{Alloc} meets
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \begin{note}
@@ -4315,7 +4315,7 @@ constexpr void swap(optional& rhs) noexcept(@\seebelow@);
 
 \pnum
 \expects
-\tcode{T} meets the \oldconcept{Swappable} requirements\iref{swappable.requirements}.
+\tcode{T} meets the \oldconceptref{Swappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -4372,7 +4372,7 @@ using const_iterator = @\impdef@;
 \pnum
 These types
 model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
-meet the \oldconcept{RandomAccessIterator} requirements\iref{random.access.iterators}, and
+meet the \oldconceptref{RandomAccessIterator} requirements\iref{random.access.iterators}, and
 meet the requirements for constexpr iterators\iref{iterator.requirements.general},
 with value type \tcode{remove_cv_t<T>}.
 The reference type is \tcode{T\&} for \tcode{iterator} and
@@ -5391,7 +5391,7 @@ template<class T, class U> constexpr bool operator==(const optional<T>& x, const
 The expression \tcode{*x == *y} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
-\tcode{T} need not be \oldconcept{EqualityComparable}.
+\tcode{T} need not be \oldconceptref{EqualityComparable}.
 \end{note}
 
 \pnum
@@ -5582,7 +5582,7 @@ template<class T, class U> constexpr bool operator==(const optional<T>& x, const
 The expression \tcode{*x == v} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
-\tcode{T} need not be \oldconcept{EqualityComparable}.
+\tcode{T} need not be \oldconceptref{EqualityComparable}.
 \end{note}
 
 \pnum
@@ -6137,7 +6137,7 @@ is nested within\iref{intro.object} the
 
 \pnum
 All types in \tcode{Types} shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 
 \pnum
 A program that instantiates the definition of \tcode{variant} with
@@ -6830,7 +6830,7 @@ constexpr void swap(variant& rhs) noexcept(@\seebelow@);
 
 \pnum
 \expects
-Each $\tcode{T}_i$ meets the \oldconcept{Swappable} requirements\iref{swappable.requirements}.
+Each $\tcode{T}_i$ meets the \oldconceptref{Swappable} requirements\iref{swappable.requirements}.
 
 \pnum
 \effects
@@ -6875,7 +6875,7 @@ template<class T> struct variant_size;
 \begin{itemdescr}
 \pnum
 All specializations of \tcode{variant_size} meet the
-\oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts}
+\oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}
 with a base characteristic of \tcode{integral_constant<size_t, N>} for some \tcode{N}.
 \end{itemdescr}
 
@@ -6888,7 +6888,7 @@ template<class T> struct variant_size<const T>;
 \pnum
 Let \tcode{VS} denote \tcode{variant_size<T>} of the cv-unqualified
 type \tcode{T}. Then each specialization of the template meets the
-\oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
+\oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts} with a
 base characteristic of \tcode{integral_constant<size_t, VS::value>}.
 \end{itemdescr}
 
@@ -6908,7 +6908,7 @@ template<size_t I, class T> struct variant_alternative<I, const T>;
 \pnum
 Let \tcode{VA} denote \tcode{variant_alternative<I, T>} of the
 cv-unqualified type \tcode{T}. Then each specialization of the template
-meets the \oldconcept{TransformationTrait} requirements\iref{meta.rqmts} with a
+meets the \oldconceptref{TransformationTrait} requirements\iref{meta.rqmts} with a
 member typedef \tcode{type} that names the type \tcode{const VA::type}.
 \end{itemdescr}
 
@@ -7639,7 +7639,7 @@ and \tcode{is_copy_constructible_v<VT>} is \tcode{true}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -7667,7 +7667,7 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -7700,7 +7700,7 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -7785,7 +7785,7 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -7820,7 +7820,7 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -7864,7 +7864,7 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \effects
@@ -8571,9 +8571,9 @@ that is not a valid template argument for \tcode{unexpected} is ill-formed.
 
 \pnum
 When \tcode{T} is not \cv{} \tcode{void}, it shall meet
-the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
+the \oldconceptref{Destructible} requirements (\tref{cpp17.destructible}).
 \tcode{E} shall meet
-the \oldconcept{Destructible} requirements.
+the \oldconceptref{Destructible} requirements.
 
 \rSec3[expected.object.cons]{Constructors}
 
@@ -9847,7 +9847,7 @@ template<class T2> friend constexpr bool operator==(const expected& x, const T2&
 The expression \tcode{*x == v} is well-formed and
 its result is convertible to \tcode{bool}.
 \begin{note}
-\tcode{T} need not be \oldconcept{EqualityComparable}.
+\tcode{T} need not be \oldconceptref{EqualityComparable}.
 \end{note}
 
 \pnum
@@ -9990,7 +9990,7 @@ is not a valid template argument for \tcode{unexpected} is ill-formed.
 
 \pnum
 \tcode{E} shall meet the requirements of
-\oldconcept{Destructible} (\tref{cpp17.destructible}).
+\oldconceptref{Destructible} (\tref{cpp17.destructible}).
 
 \rSec3[expected.void.cons]{Constructors}
 
@@ -12163,8 +12163,8 @@ is ill-formed.
 \indextext{call wrapper}%
 \indextext{call wrapper!simple}%
 \indextext{call wrapper!forwarding}%
-Every call wrapper\iref{func.def} meets the \oldconcept{MoveConstructible}
-and \oldconcept{Destructible} requirements.
+Every call wrapper\iref{func.def} meets the \oldconceptref{MoveConstructible}
+and \oldconceptref{Destructible} requirements.
 An \defn{argument forwarding call wrapper} is a
 call wrapper that can be called with an arbitrary argument list
 and delivers the arguments to the target object as references.
@@ -12204,7 +12204,7 @@ with references as described in the corresponding forwarding steps.
 \pnum
 \label{term.simple.call.wrapper}%
 A \defn{simple call wrapper} is a perfect forwarding call wrapper that meets
-the \oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} requirements
+the \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements
 and whose copy constructor, move constructor, and assignment operators
 are constexpr functions that do not throw exceptions.
 
@@ -12307,7 +12307,7 @@ namespace std {
 \end{codeblock}
 
 \pnum
-\tcode{reference_wrapper<T>} is a \oldconcept{CopyConstructible} and \oldconcept{CopyAssignable} wrapper
+\tcode{reference_wrapper<T>} is a \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} wrapper
 around a reference to an object or function of type \tcode{T}.
 
 \pnum
@@ -13761,7 +13761,7 @@ is \tcode{true}.
 
 \pnum
 \expects
-\tcode{FD} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{FD} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \returns
@@ -13847,10 +13847,10 @@ is \tcode{true}.
 
 \pnum
 \expects
-\tcode{FD} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{FD} meets the \oldconceptref{MoveConstructible} requirements.
 For each $\tcode{T}_i$ in \tcode{BoundArgs},
 if $\tcode{T}_i$ is an object type,
-$\tcode{T}_i$ meets the \oldconcept{MoveConstructible} requirements.
+$\tcode{T}_i$ meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \returns
@@ -13916,7 +13916,7 @@ then \tcode{f != nullptr} is \tcode{true}.
 \pnum
 \expects
 For each $\tcode{T}_i$ in \tcode{BoundArgs},
-$\tcode{T}_i$ meets the \oldconcept{MoveConstructible} requirements.
+$\tcode{T}_i$ meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \returns
@@ -13962,7 +13962,7 @@ uses \tcode{is_bind_expression} to detect subexpressions.
 
 \pnum
 Specializations of the \tcode{is_bind_expression} template shall meet
-the \oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
+the \oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
 provides a definition that has a base characteristic of
 \tcode{true_type} if \tcode{T} is a type returned from \tcode{bind},
 otherwise it has a base characteristic of \tcode{false_type}.
@@ -13998,7 +13998,7 @@ The function template \tcode{bind} uses
 
 \pnum
 Specializations of the \tcode{is_placeholder} template shall meet
-the \oldconcept{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
+the \oldconceptref{UnaryTypeTrait} requirements\iref{meta.rqmts}. The implementation
 provides a definition that has the base characteristic of
 \tcode{integral_constant<int, \placeholder{J}>} if \tcode{T} is the type of
 \tcode{std::placeholders::_\placeholder{J}}, otherwise it has a
@@ -14048,7 +14048,7 @@ in \tcode{BoundArgs}, \tcode{is_cons\-tructible_v<$\tcode{TD}_i$, $\tcode{T}_i$>
 \pnum
 \expects
 \tcode{FD} and each $\tcode{TD}_i$ meet
-the \oldconcept{MoveConstructible} and \oldconcept{Destructible} requirements.
+the \oldconceptref{MoveConstructible} and \oldconceptref{Destructible} requirements.
 \tcode{\placeholdernc{INVOKE}(fd, $\tcode{w}_1$, $\tcode{w}_2$, $\dotsc$,
 $\tcode{w}_N$)}\iref{func.require} is a valid expression for some
 values $\tcode{w}_1$, $\tcode{w}_2$, $\dotsc{}$, $\tcode{w}_N$, where
@@ -14084,8 +14084,8 @@ the state entities of \tcode{g}.
 \pnum
 \begin{note}
 If all of \tcode{FD} and $\tcode{TD}_i$ meet
-the requirements of \oldconcept{CopyConstructible}, then
-the return type meets the requirements of \oldconcept{CopyConstructible}.
+the requirements of \oldconceptref{CopyConstructible}, then
+the return type meets the requirements of \oldconceptref{CopyConstructible}.
 \end{note}
 \end{itemdescr}
 
@@ -14154,13 +14154,13 @@ The number \tcode{\placeholder{M}} of placeholders is
 \impldef{number of placeholders for bind expressions}.
 
 \pnum
-All placeholder types meet the \oldconcept{DefaultConstructible} and
-\oldconcept{CopyConstructible} requirements, and
+All placeholder types meet the \oldconceptref{DefaultConstructible} and
+\oldconceptref{CopyConstructible} requirements, and
 their default constructors and copy/move
 constructors are constexpr functions that
 do not throw exceptions. It is \impldef{assignability of placeholder
 objects} whether
-placeholder types meet the \oldconcept{CopyAssignable} requirements,
+placeholder types meet the \oldconceptref{CopyAssignable} requirements,
 but if so, their copy assignment operators are
 constexpr functions that do not throw exceptions.
 
@@ -14430,7 +14430,7 @@ Let \tcode{FD} be \tcode{decay_t<F>}.
 
 \pnum
 \expects
-\tcode{FD} meets the \oldconcept{CopyConstructible} requirements.
+\tcode{FD} meets the \oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -14855,9 +14855,9 @@ Let \tcode{VT} be \tcode{decay_t<F>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} requirements, and
+\tcode{VT} meets the \oldconceptref{Destructible} requirements, and
 if \tcode{is_move_constructible_v<VT>} is \tcode{true},
-\tcode{VT} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \ensures
@@ -14907,9 +14907,9 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} requirements, and
+\tcode{VT} meets the \oldconceptref{Destructible} requirements, and
 if \tcode{is_move_constructible_v<VT>} is \tcode{true},
-\tcode{VT} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \ensures
@@ -14949,9 +14949,9 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} requirements, and
+\tcode{VT} meets the \oldconceptref{Destructible} requirements, and
 if \tcode{is_move_constructible_v<VT>} is \tcode{true},
-\tcode{VT} meets the \oldconcept{MoveConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{MoveConstructible} requirements.
 
 \pnum
 \ensures
@@ -15273,8 +15273,8 @@ Let \tcode{VT} be \tcode{decay_t<F>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} and
-\oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{Destructible} and
+\oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -15329,8 +15329,8 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} and
-\oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{Destructible} and
+\oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -15375,8 +15375,8 @@ Let \tcode{VT} be \tcode{decay_t<T>}.
 
 \pnum
 \expects
-\tcode{VT} meets the \oldconcept{Destructible} and
-\oldconcept{CopyConstructible} requirements.
+\tcode{VT} meets the \oldconceptref{Destructible} and
+\oldconceptref{CopyConstructible} requirements.
 
 \pnum
 \ensures
@@ -15937,7 +15937,7 @@ provided to the function call operator.
 
 \pnum
 Each specialization of a class template specified in \ref{func.search}
-shall meet the \oldconcept{CopyConst\-ruct\-ible} and \oldconcept{CopyAssignable} requirements.
+shall meet the \oldconceptref{CopyConstructible} and \oldconceptref{CopyAssignable} requirements.
 Template parameters named
 \begin{itemize}
 \item \tcode{ForwardIterator},
@@ -15951,7 +15951,7 @@ Template parameters named
 of templates specified in
 \ref{func.search} shall meet the same requirements and semantics as
 specified in \ref{algorithms.general}.
-Template parameters named \tcode{Hash} shall meet the \oldconcept{Hash}
+Template parameters named \tcode{Hash} shall meet the \oldconceptref{Hash}
 requirements (\tref{cpp17.hash}).
 
 \pnum
@@ -16060,9 +16060,9 @@ boyer_moore_searcher(RandomAccessIterator1 pat_first,
 \pnum
 \expects
 The value type of \tcode{RandomAccessIterator1} meets
-the \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible}, and
-\oldconcept{CopyAssignable} requirements.
+the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible}, and
+\oldconceptref{CopyAssignable} requirements.
 
 \pnum
 Let \tcode{V} be \tcode{iterator_traits<RandomAccessIterator1>::val\-ue_type}.
@@ -16161,8 +16161,8 @@ boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
 \begin{itemdescr}
 \pnum
 \expects
-The value type of \tcode{RandomAccessIterator1} meets the \oldconcept{DefaultConstructible},
-\oldconcept{Copy\-Constructible}, and \oldconcept{CopyAssignable} requirements.
+The value type of \tcode{RandomAccessIterator1} meets the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible}, and \oldconceptref{CopyAssignable} requirements.
 
 \pnum
 Let \tcode{V} be \tcode{iterator_traits<RandomAccessIterator1>::val\-ue_type}.
@@ -16235,7 +16235,7 @@ as the default hash function.
 Each specialization of \tcode{hash} is either enabled or disabled,
 as described below.
 \begin{note}
-Enabled specializations meet the \oldconcept{Hash} requirements, and
+Enabled specializations meet the \oldconceptref{Hash} requirements, and
 disabled specializations do not.
 \end{note}
 Each header that declares the template \tcode{hash}
@@ -16262,17 +16262,17 @@ Disabled specializations of \tcode{hash}
 are not function object types\iref{function.objects}.
 \begin{note}
 This means that the specialization of \tcode{hash} exists, but
-any attempts to use it as a \oldconcept{Hash} will be ill-formed.
+any attempts to use it as a \oldconceptref{Hash} will be ill-formed.
 \end{note}
 
 \pnum
 An enabled specialization \tcode{hash<Key>} will:
 \begin{itemize}
-\item meet the \oldconcept{Hash} requirements (\tref{cpp17.hash}),
+\item meet the \oldconceptref{Hash} requirements (\tref{cpp17.hash}),
 with \tcode{Key} as the function
-call argument type, the \oldconcept{Default\-Constructible} requirements (\tref{cpp17.defaultconstructible}),
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}),
-the \oldconcept{Swappable} requirements\iref{swappable.requirements},
+call argument type, the \oldconceptref{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
+the \oldconceptref{CopyAssignable} requirements (\tref{cpp17.copyassignable}),
+the \oldconceptref{Swappable} requirements\iref{swappable.requirements},
 \item meet the requirement that if \tcode{k1 == k2} is \tcode{true}, \tcode{h(k1) == h(k2)} is
 also \tcode{true}, where \tcode{h} is an object of type \tcode{hash<Key>} and \tcode{k1} and \tcode{k2}
 are objects of type \tcode{Key};
-- 
2.43.0


From 054d99887cef53f7417a1df5cf826f61f52ed7d5 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 28 Jul 2024 11:08:01 +0200
Subject: [PATCH 8/9] Remove awkward \linebreaks.

---
 source/algorithms.tex |  4 ++--
 source/containers.tex | 38 +++++++++++++++++++-------------------
 source/exec.tex       |  8 ++++----
 source/memory.tex     |  6 +++---
 source/meta.tex       |  2 +-
 source/ranges.tex     | 38 +++++++++++++++++++-------------------
 source/threads.tex    |  8 ++++----
 source/utilities.tex  |  8 ++++----
 8 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex
index b86bfc2a..5b4fb286 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -7072,7 +7072,7 @@ Let:
     \tcode{invoke(op, invoke(proj, *(first1 + (i - result))))}
     for unary transforms defined in namespace \tcode{ranges};
   \item
-    \tcode{invoke(binary_op, invoke(proj1, *(first1 + (i - result))), invoke(proj2,\linebreak *(first2 + (i - result))))}
+    \tcode{invoke(binary_op, invoke(proj1, *(first1 + (i - result))), invoke(proj2, *(first2 + (i - result))))}
     for binary transforms defined in namespace \tcode{ranges}.
   \end{itemize}
 \end{itemize}
@@ -14211,7 +14211,7 @@ namespace ranges {
 \pnum
 \constraints
 \tcode{is_unbounded_array_v<T>} is \tcode{false}.
-The expression \tcode{::new (declval<void*>()) T(\linebreak{}declval<Args>()...)}
+The expression \tcode{::new (declval<void*>()) T(declval<Args>()...)}
 is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
diff --git a/source/containers.tex b/source/containers.tex
index d8ea438f..4b76dafc 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -1462,7 +1462,7 @@ Each iterator in the range \tcode{rg} is dereferenced exactly once.
 \pnum
 \recommended
 If \tcode{R} models \tcode{ranges::\libconcept{approximately_sized_range}} and
-\tcode{ranges::distance(\linebreak{}rg) <= ranges::reserve_hint(rg)} is \tcode{true},
+\tcode{ranges::distance(rg) <= ranges::reserve_hint(rg)} is \tcode{true},
 an implementation should not perform more than a single reallocation.
 
 \pnum
@@ -1837,7 +1837,7 @@ Each iterator in the range \tcode{rg} is dereferenced exactly once.
 \pnum
 \recommended
 If \tcode{R} models \tcode{ranges::\libconcept{approximately_sized_range}} and
-\tcode{ranges::distance(\linebreak{}rg) <= ranges::reserve_hint(rg)} is \tcode{true},
+\tcode{ranges::distance(rg) <= ranges::reserve_hint(rg)} is \tcode{true},
 an implementation should not perform any reallocation.
 \end{itemdescr}
 
@@ -2458,7 +2458,7 @@ Assigns \tcode{nh.\exposid{ptr_}} to \exposid{ptr_}.
 \item
 If \tcode{!\exposid{alloc_}} is \tcode{true} or
 \tcode{\exposid{ator-traits}::propagate_on_container_move_assignment::value}
-is \tcode{true}, \linebreak
+is \tcode{true},
 move assigns \tcode{nh.\exposid{alloc_}} to \exposid{alloc_}.
 \item
 Assigns
@@ -7492,14 +7492,14 @@ template<class... Args>
 \pnum
 \expects
 \tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{forward_list}
-from \tcode{std::forward<Args>(\linebreak args)...}.
+from \tcode{std::forward<Args>(args)...}.
 \tcode{position} is \tcode{before_begin()} or is a dereferenceable
 iterator in the range \range{begin()}{end()}.
 
 \pnum
 \effects
 Inserts an object of type \tcode{value_type} direct-non-list-initialized with
-\tcode{std::forward<Args>(\linebreak args)...} after \tcode{position}.
+\tcode{std::forward<Args>(args)...} after \tcode{position}.
 
 \pnum
 \returns
@@ -10757,7 +10757,7 @@ template<class T>
 \pnum
 The expression
 \tcode{\exposid{is-vector-bool-reference}<T>} is \tcode{true}
-if \tcode{T} denotes the type \tcode{vector<bool, Alloc>::\linebreak{}reference}
+if \tcode{T} denotes the type \tcode{vector<bool, Alloc>::reference}
 for some type \tcode{Alloc} and
 \tcode{vector<bool, Alloc>} is not a program-defined specialization.
 \end{itemdescr}
@@ -12172,7 +12172,7 @@ there is no effect.
 Otherwise, let \tcode{r} be \tcode{equal_range(k)}.
 Constructs an object \tcode{u} of type \tcode{value_type} with
 \tcode{piecewise_construct, forward_as_tuple(std::forward<K>(k)),
-forward_as_tuple(std::forward<Args>(args)...)}.\linebreak
+forward_as_tuple(std::forward<Args>(args)...)}.
 If \tcode{equal_range(u.first) == r} is \tcode{false},
 the behavior is undefined.
 Inserts \tcode{u} into \tcode{*this}.
@@ -17933,7 +17933,7 @@ template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
 \pnum
 \effects
 Initializes an object \tcode{t} of type \tcode{pair<key_type, mapped_type>}
-with \tcode{std::forward<Args>(\linebreak args)...};
+with \tcode{std::forward<Args>(args)...};
 if the map already contains an element
 whose key is equivalent to \tcode{t.first},
 \tcode{*this} is unchanged.
@@ -18205,7 +18205,7 @@ template<class M>
 \effects
 If the map already contains an element \tcode{e}
 whose key is equivalent to \tcode{k},
-assigns \tcode{std::forward<\linebreak M>(obj)} to \tcode{e.second}.
+assigns \tcode{std::forward<M>(obj)} to \tcode{e.second}.
 Otherwise, equivalent to
 \begin{codeblock}
 try_emplace(std::forward<decltype(k)>(k), std::forward<M>(obj))
@@ -18260,7 +18260,7 @@ an object \tcode{u}, for which \tcode{find(k) == find(u)} is \tcode{true}.
 \effects
 If the map already contains an element \tcode{e}
 whose key is equivalent to \tcode{k},
-assigns \tcode{std::forward<\linebreak M>(obj)} to \tcode{e.second}.
+assigns \tcode{std::forward<M>(obj)} to \tcode{e.second}.
 Otherwise, equivalent to
 \begin{codeblock}
 try_emplace(std::forward<K>(k), std::forward<M>(obj))
@@ -18890,14 +18890,14 @@ template<class Alloc>
 \pnum
 \effects
 Equivalent to \tcode{flat_multimap(key_cont, mapped_cont)} and
-\tcode{flat_multimap(key_cont, \linebreak{}mapped_cont, comp)}, respectively,
+\tcode{flat_multimap(key_cont, mapped_cont, comp)}, respectively,
 except that \tcode{\exposid{c}.keys} and \tcode{\exposid{c}.values} are constructed
 with uses-allocator construction\iref{allocator.uses.construction}.
 
 \pnum
 \complexity
 Same as \tcode{flat_multimap(key_cont, mapped_cont)} and
-\tcode{flat_multimap(key_cont, \linebreak{}mapped_cont, comp)}, respectively.
+\tcode{flat_multimap(key_cont, mapped_cont, comp)}, respectively.
 \end{itemdescr}
 
 \indexlibraryctor{flat_multimap}%
@@ -23585,7 +23585,7 @@ is representable as a value of type \tcode{index_type.}
 \item
 If \exposid{rank_} is greater than one,
 then the product of
-\tcode{\exposid{LEAST-MULTIPLE-AT-LEAST}(pad, ext.extent(\linebreak 0))} and
+\tcode{\exposid{LEAST-MULTIPLE-AT-LEAST}(pad, ext.extent(0))} and
 all values \tcode{ext.extent($k$)}
 with $k$ in the range of \range{1}{\exposid{rank_}}
 is representable as a value of type \tcode{index_type}.
@@ -23664,7 +23664,7 @@ template<class OtherExtents>
 \item
 If \exposid{rank_} is greater than \tcode{1} and
 \tcode{padding_value} does not equal \tcode{dynamic_extent},
-then \tcode{other.\linebreak stride(1)} equals
+then \tcode{other.stride(1)} equals
 \begin{codeblock}
 @\exposid{LEAST-MULTIPLE-AT-LEAST}@(padding_value,
                         extents_type::@\exposid{index-cast}@(other.extents().extent(0)))
@@ -23739,7 +23739,7 @@ is \tcode{true}.
 \item
 If \exposid{rank_} is greater than 1 and
 \tcode{padding_value} does not equal \tcode{dynamic_extent},
-then \tcode{other.\linebreak stride(1)} equals
+then \tcode{other.stride(1)} equals
 \begin{codeblock}
 @\exposid{LEAST-MULTIPLE-AT-LEAST}@(padding_value,
                         extents_type::@\exposid{index-cast}@(other.extent(0)))
@@ -24147,7 +24147,7 @@ Implementations should not store this value
 if \exposid{static-padding-stride} is not \tcode{dynamic_extent}.
 \begin{note}
 Using \tcode{extents<index_type, \exposid{static-padding-stride}>}
-instead of \tcode{index_type} as the type of \exposid{stride-\linebreak rm2}
+instead of \tcode{index_type} as the type of \exposid{stride-rm2}
 would achieve this.
 \end{note}
 \end{itemdescr}
@@ -24234,7 +24234,7 @@ is representable as a value of type \tcode{index_type}.
 \item
 If \exposid{rank_} is greater than one,
 then the product of
-\tcode{\exposid{LEAST-MULTIPLE-AT-LEAST}(pad, ext.extent(\exposid{\linebreak rank_} - 1))} and
+\tcode{\exposid{LEAST-MULTIPLE-AT-LEAST}(pad, ext.extent(\exposid{rank_} - 1))} and
 all values \tcode{ext.extent($k$)}
 with $k$ in the range of \range{0}{\exposid{rank_} - 1}
 is representable as a value of type \tcode{index_type}.
@@ -24313,7 +24313,7 @@ template<class OtherExtents>
 \item
 If \exposid{rank_} is greater than 1 and
 \tcode{padding_value} does not equal \tcode{dynamic_extent},
-then \tcode{other.\linebreak stride(\exposid{rank_} - 2)} equals
+then \tcode{other.stride(\exposid{rank_} - 2)} equals
 \begin{codeblock}
 @\exposid{LEAST-MULTIPLE-AT-LEAST}@(padding_value,
                         extents_type::@\exposid{index-cast}@(other.extents().extent(@\exposid{rank_}@ - 1)))
@@ -24388,7 +24388,7 @@ is \tcode{true}.
 \item
 If \exposid{rank_} is greater than 1 and
 \tcode{padding_value} does not equal \tcode{dynamic_extent},
-then \tcode{other.\linebreak stride(\exposid{rank_} - 2)} equals
+then \tcode{other.stride(\exposid{rank_} - 2)} equals
 \begin{codeblock}
 @\exposid{LEAST-MULTIPLE-AT-LEAST}@(padding_value,
                         extents_type::@\exposid{index-cast}@(other.extent(@\exposid{rank_}@ - 1)))
diff --git a/source/exec.tex b/source/exec.tex
index 4acd1841..c6948141 100644
--- a/source/exec.tex
+++ b/source/exec.tex
@@ -3914,7 +3914,7 @@ otherwise, it is expression-equivalent to
 \pnum
 Let \tcode{out_sndr} and \tcode{env} be subexpressions,
 let \tcode{OutSndr} be \tcode{decltype((out_sndr))}, and
-let \tcode{Env} be \tcode{decltype((\linebreak env))}.
+let \tcode{Env} be \tcode{decltype((env))}.
 If \tcode{\exposconcept{sender-for}<OutSndr, on_t>} is \tcode{false},
 then the expression \tcode{on.transform_sender(set_value, out_sndr, env)} is ill-formed.
 
@@ -4019,7 +4019,7 @@ Let the expression \exposid{then-cpo} be one of
 For subexpressions \tcode{sndr} and \tcode{f},
 if \tcode{decltype((sndr))} does not satisfy \libconcept{sender}, or
 \tcode{decltype((f))} does not satisfy \exposconcept{movable-value},
-\tcode{\exposid{then-cpo}(\linebreak sndr, f) }is ill-formed.
+\tcode{\exposid{then-cpo}(sndr, f) }is ill-formed.
 
 \pnum
 Otherwise,
@@ -4979,7 +4979,7 @@ try {
 \end{codeblock}
 if the expression \tcode{\exposid{decayed-tuple}<decltype(as)...>\{as...\}}
 is potentially throwing;
-otherwise, \tcode{o.emplace(\linebreak as...)}.
+otherwise, \tcode{o.emplace(as...)}.
 
 \pnum
 The expression \tcode{when_all_with_variant(sndrs...)}
@@ -6150,7 +6150,7 @@ Equivalent to \tcode{\exposid{state}->\exposid{loop}.finish()}.
 
 \pnum
 For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.
-If \tcode{\exposconcept{sender-to}<Sndr, \exposid{sync-wait-receiver}<\linebreak Sndr>>}
+If \tcode{\exposconcept{sender-to}<Sndr, \exposid{sync-wait-receiver}<Sndr>>}
 is \tcode{false},
 the expression \tcode{sync_wait.apply_sender(sndr)} is ill-formed;
 otherwise, it is equivalent to:
diff --git a/source/memory.tex b/source/memory.tex
index 8fb09ade..d4799964 100644
--- a/source/memory.tex
+++ b/source/memory.tex
@@ -1325,7 +1325,7 @@ A \tcode{tuple} value determined as follows:
 \begin{itemize}
 \item
   If \tcode{uses_allocator_v<remove_cv_t<T>, Alloc>} is \tcode{false} and
-  \tcode{is_constructible_v<T,\linebreak Args...>} is \tcode{true},
+  \tcode{is_constructible_v<T, Args...>} is \tcode{true},
   return \tcode{forward_as_tuple(std::forward<Args>(args)...)}.
 \item
   Otherwise, if \tcode{uses_allocator_v<remove_cv_t<T>, Alloc>} is \tcode{true} and
@@ -4712,7 +4712,7 @@ an exception thrown from \tcode{allocate} or from the initialization of the obje
   the allocator \tcode{a} passed to \tcode{allocate_shared}.
 \item
   When a (sub)object of non-array type \tcode{U} is initialized by
-  \tcode{make_shared_for_overwrite} or\linebreak % avoid Overfull
+  \tcode{make_shared_for_overwrite} or
   \tcode{allocate_shared_for_overwrite},
   it is initialized via the expression \tcode{::new(pv) U},
   where \tcode{pv} has type \tcode{void*} and
@@ -5947,7 +5947,7 @@ if (p) {
 \end{codeblock}
 if the expression
 \tcode{s.reset(static_cast<SP>(p), std::forward<Args>(args)...)}
-is well-\linebreak formed;
+is well-formed;
 \item
 otherwise,
 \begin{codeblock}
diff --git a/source/meta.tex b/source/meta.tex
index 9975819b..32203914 100644
--- a/source/meta.tex
+++ b/source/meta.tex
@@ -2273,7 +2273,7 @@ present as follows:
   \item Let \tcode{R} be \tcode{\placeholdernc{COMMON-REF}(T1, T2)}.
     If \tcode{T1} and \tcode{T2} are reference types,
     \tcode{R} is well-formed, and
-    \tcode{is_convertible_v<add_pointer_t<T1>, add_pointer_t<R>> \&\& is_convertible_v<add_poin\linebreak{}ter_t<T2>, add_pointer_t<R>>} is \tcode{true},
+    \tcode{is_convertible_v<add_pointer_t<T1>, add_pointer_t<R>> \&\& is_convertible_v<add_pointer_t<T2>, add_pointer_t<R>>} is \tcode{true},
     then the member typedef \tcode{type} denotes \tcode{R}.
 
   \item Otherwise, if
diff --git a/source/ranges.tex b/source/ranges.tex
index 6305fe97..58b567da 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -1452,7 +1452,7 @@ if \tcode{iterator_t<T>} models \libconcept{forward_iterator},
 regardless of the evaluation of \tcode{ranges::begin(t)}.
 \begin{note}
 \tcode{ranges::reserve_hint(t)} is otherwise not required to be well-defined
-after evaluating \tcode{ranges::\linebreak begin(t)}.
+after evaluating \tcode{ranges::begin(t)}.
 For example,
 it is possible for \tcode{ranges::reserve_hint(t)} to be well-defined for
 an \libconceptx{approximate\-ly_sized_range}{approximately_sized_range} whose
@@ -3665,7 +3665,7 @@ constexpr explicit repeat_view(piecewise_construct_t,
 Initializes \exposid{value_} with
 \tcode{make_from_tuple<T>(std::move(value_args))}
 and
-initializes\linebreak{} \exposid{bound_} with
+initializes \exposid{bound_} with
 \tcode{make_from_tuple<Bound>(std::move(bound_args))}.
 The behavior is undefined if
 \tcode{Bound} is not \tcode{unreachable_sentinel_t} and
@@ -5890,7 +5890,7 @@ a specialization of \tcode{iota_view}\iref{range.iota.view}
 that models \libconcept{random_access_range} and \libconcept{sized_range},
 then
 \tcode{iota_view(*ranges::begin(E),
-*(ranges::begin(E) + std::\linebreak{}min<D>(ranges::distance(E), F)))},
+*(ranges::begin(E) + std::min<D>(ranges::distance(E), F)))},
 except that \tcode{E} is evaluated only once.
 
 \item
@@ -6371,7 +6371,7 @@ if \tcode{T} is
 a specialization of \tcode{subrange}
 that models \libconcept{random_access_range} and \libconcept{sized_range},
 then
-\tcode{T(ranges::begin(E) + std::min<D>(ranges::distance(E), F), ranges::\linebreak{}end(E),
+\tcode{T(ranges::begin(E) + std::min<D>(ranges::distance(E), F), ranges::end(E),
 \exposid{to-unsigned-like}(ranges::distance(E) -
 std::min<D>(ranges::distance(E), F)))},
 except that \tcode{E} and \tcode{F} are each evaluated only once.
@@ -7381,7 +7381,7 @@ Let \placeholder{OUTERC} denote
 let \placeholder{INNERC} denote
 \tcode{iterator_traits<\exposid{InnerIter}>::iterator_category}, and
 let \placeholder{PATTERNC} denote
-\tcode{iterator_-\linebreak traits<\exposid{PatternIter}>::iterator_category}.
+\tcode{iterator_traits<\exposid{PatternIter}>::iterator_category}.
 \item
 If
 \begin{codeblock}
@@ -7857,7 +7857,7 @@ constexpr explicit lazy_split_view(R&& r, range_value_t<R> e);
 \pnum
 \effects
 Initializes \exposid{base_} with \tcode{views::all(std::forward<R>(r))}, and
-\exposid{pattern_} with \tcode{views::\linebreak single(std::move(e))}.
+\exposid{pattern_} with \tcode{views::single(std::move(e))}.
 \end{itemdescr}
 
 \rSec3[range.lazy.split.outer]{Class template \tcode{lazy_split_view::\exposid{outer-iterator}}}
@@ -8162,7 +8162,7 @@ Otherwise, the \grammarterm{typedef-name} \tcode{iterator_category} denotes:
 \begin{itemize}
 \item
 \tcode{forward_iterator_tag} if
-\tcode{iterator_traits<iterator_t<\exposid{Base}>>::iterator_category} models \linebreak
+\tcode{iterator_traits<iterator_t<\exposid{Base}>>::iterator_category} models
 \tcode{\libconcept{derived_from}<forward_iterator_tag>};
 \item otherwise, \tcode{iterator_traits<iterator_t<\exposid{Base}>>::iterator_category}.
 \end{itemize}
@@ -8382,7 +8382,7 @@ constexpr explicit split_view(R&& r, range_value_t<R> e);
 \pnum
 \effects
 Initializes \exposid{base_} with \tcode{views::all(std::forward<R>(r))}, and
-\exposid{pattern_} with \tcode{views::\linebreak single(std::move(e))}.
+\exposid{pattern_} with \tcode{views::single(std::move(e))}.
 \end{itemdescr}
 
 \indexlibrarymember{begin}{split_view}
@@ -8952,7 +8952,7 @@ then \tcode{iterator_concept} denotes \tcode{bidirectional_iterator_tag}.
 \item
 Otherwise, if
 \tcode{\exposconcept{all-forward}<Const, Views...>} is modeled,
-then \tcode{iterator_concept} denotes \tcode{for\-ward_iterator_tag}.
+then \tcode{iterator_concept} denotes \tcode{forward_iterator_tag}.
 \item
 Otherwise, \tcode{iterator_concept} denotes \tcode{input_iterator_tag}.
 \end{itemize}
@@ -8978,14 +8978,14 @@ let \tcode{Cs} denote the pack of types
 \begin{itemize}
 \item
 If
-\tcode{(\libconcept{derived_from}<Cs, random_access_iterator_tag> \&\& ...) \&\& \exposconceptx{concat-is-random-ac-\linebreak{}cess}{concat-is-random-access}<Const, Views...>}
+\tcode{(\libconcept{derived_from}<Cs, random_access_iterator_tag> \&\& ...) \&\& \exposconceptx{concat-is-random-access}{concat-is-random-access}<Const, Views...>}
 is \tcode{true},
 \tcode{iterator_category} denotes \tcode{random_access_iterator_tag}.
 \item
 Otherwise, if
-\tcode{(\libconcept{derived_from}<Cs, bidirectional_iterator_tag> \&\& ...) \&\& \exposconceptx{concat-is-\linebreak{}bidirectional}{concat-is-bidirectional}<Const, Views...>}
+\tcode{(\libconcept{derived_from}<Cs, bidirectional_iterator_tag> \&\& ...) \&\& \exposconceptx{concat-is-bidirectional}{concat-is-bidirectional}<Const, Views...>}
 is \tcode{true},
-\tcode{iterator_category} denotes \tcode{bidirectional_iter\-ator_tag}.
+\tcode{iterator_category} denotes \tcode{bidirectional_iterator_tag}.
 \item
 Otherwise, if
 \tcode{(\libconcept{derived_from}<Cs, forward_iterator_tag> \&\& ...)}
@@ -9403,11 +9403,11 @@ Let
 %FIXME This is hard to parse.
 If \tcode{$i_\tcode{x}$ > $i_\tcode{y}$}, let
 \tcode{$d_\tcode{y}$} be
-\tcode{ranges::distance(std::get<$i_\tcode{y}$>(y.\exposid{it_}), ranges::end(std::get<$i_\tcode{y}$>(y.\linebreak{}\exposid{parent_}->\exposid{views_})))},
+\tcode{ranges::distance(std::get<$i_\tcode{y}$>(y.\exposid{it_}), ranges::end(std::get<$i_\tcode{y}$>(y.\exposid{parent_}->\exposid{views_})))},
 \tcode{$d_\tcode{x}$} be
-\tcode{ranges::distance(ranges::begin(std::get<$i_\tcode{x}$>(x.\exposid{parent_}->\linebreak{}\exposid{views_})), std::get<$i_\tcode{x}$>(x.\exposid{it_}))}.
+\tcode{ranges::distance(ranges::begin(std::get<$i_\tcode{x}$>(x.\exposid{parent_}->\exposid{views_})), std::get<$i_\tcode{x}$>(x.\exposid{it_}))}.
 Let \tcode{$s$} denote the sum of the sizes of all the ranges
-\tcode{std::get<\linebreak{}$i$>(x.\exposid{parent_}->\exposid{views_})}
+\tcode{std::get<$i$>(x.\exposid{parent_}->\exposid{views_})}
 for every integer \tcode{$i$} in the range
 \range{$i_\tcode{y}$ + 1}{$i_\tcode{x}$}
 if there is any, and
@@ -9450,7 +9450,7 @@ friend constexpr difference_type operator-(const @\exposid{iterator}@& x, defaul
 Let
 \tcode{$i_\tcode{x}$} denote \tcode{x.\exposid{it_}.index()},
 \tcode{$d_\tcode{x}$} be
-\tcode{ranges::distance(std::get<$i_\tcode{x}$>(x.\exposid{it_}), ranges::\linebreak{}end(std::get<$i_\tcode{x}$>(x.\exposid{parent_}->\exposid{views_})))}.
+\tcode{ranges::distance(std::get<$i_\tcode{x}$>(x.\exposid{it_}), ranges::end(std::get<$i_\tcode{x}$>(x.\exposid{parent_}->\exposid{views_})))}.
 Let \tcode{$s$} denote the sum of the sizes of all the ranges
 \tcode{std::get<$i$>(x.\exposid{parent_}->\exposid{views_})}
 for every integer \tcode{$i$} in the range
@@ -9607,7 +9607,7 @@ is expression-equivalent to:
 \begin{itemize}
 \item
 If \tcode{T} models \libconcept{contiguous_iterator},
-then \tcode{span(to_address(E), static_cast<size_t>(static_-\linebreak{}cast<D>(F)))}.
+then \tcode{span(to_address(E), static_cast<size_t>(static_cast<D>(F)))}.
 
 \item
 Otherwise, if \tcode{T} models \libconcept{random_access_iterator},
@@ -13156,7 +13156,7 @@ is defined as follows:
 \item
 If \tcode{invoke_result_t<\exposid{maybe-const}<Const, F>\&,
 \exposid{REPEAT}(range_reference_t<\exposid{Base}>, N)...>}
-is\linebreak not a reference,
+is not a reference,
 \tcode{iterator_category} denotes \tcode{input_iterator_tag}.
 \item
 Otherwise, let \tcode{C} denote the type
@@ -14235,7 +14235,7 @@ constexpr @\exposid{iterator}@(@\exposid{Parent}@* parent, iterator_t<@\exposid{
 \effects
 Initializes \exposid{current_} with \tcode{current},
 \exposid{end_} with \tcode{ranges::end(parent->\exposid{base_})},
-\exposid{n_} with \tcode{parent\linebreak ->\exposid{n_}}, and
+\exposid{n_} with \tcode{parent->\exposid{n_}}, and
 \exposid{missing_} with \tcode{missing}.
 \end{itemdescr}
 
diff --git a/source/threads.tex b/source/threads.tex
index f301c230..d96ac081 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -3710,7 +3710,7 @@ constexpr bool compare_exchange_strong(value_type& expected, value_type desired,
 \tcode{failure} is
 \tcode{memory_order::relaxed},
 \tcode{memory_order::acquire}, or
-\tcode{memory_order::\linebreak seq_cst}.
+\tcode{memory_order::seq_cst}.
 
 \pnum
 \effects
@@ -5017,7 +5017,7 @@ For the \tcode{volatile} overload of this function,
 \tcode{failure} is
 \tcode{memory_order::relaxed},
 \tcode{memory_order::acquire}, or
-\tcode{memory_order::\linebreak seq_cst}.
+\tcode{memory_order::seq_cst}.
 
 \pnum
 \effects
@@ -6554,7 +6554,7 @@ constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> de
 \tcode{failure} is
 \tcode{memory_order::relaxed},
 \tcode{memory_order::acquire}, or
-\tcode{memory_order::\linebreak seq_cst}.
+\tcode{memory_order::seq_cst}.
 
 \pnum
 \effects
@@ -6870,7 +6870,7 @@ constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desire
 \tcode{failure} is
 \tcode{memory_order::relaxed},
 \tcode{memory_order::acquire}, or
-\tcode{memory_order::\linebreak seq_cst}.
+\tcode{memory_order::seq_cst}.
 
 \pnum
 \effects
diff --git a/source/utilities.tex b/source/utilities.tex
index bc5632a5..227adaa1 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -2354,7 +2354,7 @@ equals \tcode{tuple_size_v<remove_cvref_t<UTuple>>},
 
 \item
 \tcode{(is_constructible_v<Types, decltype(get<I>(std::forward<UTuple>(u)))> \&\& ...)}
-is\linebreak{} % Overfull
+is
 \tcode{true}, and
 
 \item
@@ -3373,7 +3373,7 @@ denotes a type.
 \pnum
 \result
 The member \grammarterm{typedef-name} \tcode{type} denotes the type
-\tcode{tuple<common_reference_t<TQual<TTypes>, \linebreak{}UQual<UTypes>>...>}.
+\tcode{tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>}.
 \end{itemdescr}
 
 \indexlibrarymember{common_type}{tuple}%
@@ -4380,7 +4380,7 @@ The reference type is \tcode{T\&} for \tcode{iterator} and
 
 \pnum
 All requirements on container iterators\iref{container.reqmts} apply to
-\tcode{optional::iterator} and \tcode{optional::\linebreak{}const_iterator} as well.
+\tcode{optional::iterator} and \tcode{optional::const_iterator} as well.
 
 \pnum
 Any operation that initializes or destroys the contained value of an optional object invalidates all iterators into that object.
@@ -9433,7 +9433,7 @@ constexpr const T&& value() const &&;
 \pnum
 \mandates
 \tcode{is_copy_constructible_v<E>} is \tcode{true} and
-\tcode{is_constructible_v<E, decltype(std::\linebreak{}move(error()))>} is \tcode{true}.
+\tcode{is_constructible_v<E, decltype(std::move(error()))>} is \tcode{true}.
 
 \pnum
 \returns
-- 
2.43.0


From ae95d2208203e117d3e61c8e1cb176242d2127f1 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Thu, 25 Dec 2025 12:43:53 +0100
Subject: [PATCH 9/9] Use \literalterminal more.

---
 source/lex.tex | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index 2946bff3..19211197 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -449,7 +449,7 @@ for the respective Unicode encoding form.
 
 \begin{bnf}
 \nontermdef{named-universal-character}\br
-    \terminal{\textbackslash N\{} n-char-sequence \terminal{\}}
+    \literalterminal{\textbackslash N\{} n-char-sequence \literalterminal{\}}
 \end{bnf}
 
 \begin{bnf}
@@ -464,9 +464,9 @@ for the respective Unicode encoding form.
 
 \begin{bnf}
 \nontermdef{universal-character-name}\br
-    \terminal{\textbackslash u} hex-quad\br
-    \terminal{\textbackslash U} hex-quad hex-quad\br
-    \terminal{\textbackslash u\{} simple-hexadecimal-digit-sequence \terminal{\}}\br
+    \literalterminal{\textbackslash u} hex-quad\br
+    \literalterminal{\textbackslash U} hex-quad hex-quad\br
+    \literalterminal{\textbackslash u\{} simple-hexadecimal-digit-sequence \literalterminal{\}}\br
     named-universal-character
 \end{bnf}
 
@@ -1196,14 +1196,14 @@ a literal has a type and a value category\iref{expr.prim.literal}.
 
 \begin{bnf}
 \nontermdef{binary-literal}\br
-    \terminal{0b} binary-digit\br
-    \terminal{0B} binary-digit\br
+    \literalterminal{0b} binary-digit\br
+    \literalterminal{0B} binary-digit\br
     binary-literal \opt{\literalterminal{'}} binary-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{octal-literal}\br
-    \terminal{0}\br
+    \literalterminal{0}\br
     octal-literal \opt{\literalterminal{'}} octal-digit
 \end{bnf}
 
@@ -1220,22 +1220,22 @@ a literal has a type and a value category\iref{expr.prim.literal}.
 
 \begin{bnf}
 \nontermdef{binary-digit} \textnormal{one of}\br
-    \terminal{0  1}
+    \literalterminal{0  1}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{octal-digit} \textnormal{one of}\br
-    \terminal{0  1  2  3  4  5  6  7}
+    \literalterminal{0  1  2  3  4  5  6  7}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{nonzero-digit} \textnormal{one of}\br
-    \terminal{1  2  3  4  5  6  7  8  9}
+    \literalterminal{1  2  3  4  5  6  7  8  9}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-prefix} \textnormal{one of}\br
-    \terminal{0x  0X}
+    \literalterminal{0x  0X}
 \end{bnf}
 
 \begin{bnf}
-- 
2.43.0