diff --git a/source/algorithms.tex b/source/algorithms.tex
index bdbc42eeec..b9fbc5f896 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -15,7 +15,7 @@
 and algorithms from the ISO C library,
 as summarized in \tref{algorithms.summary}.
 
-\begin{libsumtab}{Algorithms library summary}{tab:algorithms.summary}
+\begin{libsumtab}{Algorithms library summary}{algorithms.summary}
 \ref{algorithms.requirements}  & Algorithms requirements           & \\
 \ref{algorithms.parallel}      & Parallel algorithms               & \\ \rowsep
 \ref{alg.nonmodifying}         & Non-modifying sequence operations & \tcode{<algorithm>} \\
@@ -3001,10 +3001,10 @@
 \pnum
 \requires
 \tcode{Function} shall satisfy
-the \oldconcept{MoveConstructible} requirements (\tref{moveconstructible}).
+the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}).
 \begin{note}
 \tcode{Function} need not meet the requirements of
-\oldconcept{CopyConstructible} (\tref{copyconstructible}).
+\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}).
 \end{note}
 
 \pnum
@@ -4206,7 +4206,7 @@
 For the overload with an \tcode{ExecutionPolicy},
 there may be a performance cost
 if \tcode{iterator_traits<ForwardIterator1>::value_type}
-is not \oldconcept{\-Move\-Constructible} (\tref{moveconstructible}).
+is not \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}).
 \end{note}
 
 \pnum
@@ -4989,7 +4989,7 @@
 \requires
 For the algorithms in namespace \tcode{std},
 the type of \tcode{*first}
-shall meet the \oldconcept{MoveAssignable} requirements (\tref{moveassignable}).
+shall meet the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -5089,7 +5089,7 @@
 For the overloads with an \tcode{ExecutionPolicy},
 there may be a performance cost
 if \tcode{iterator_traits<ForwardIterator1>::value_type} does not meet
-the \oldconcept{\-Move\-Constructible} (\tref{moveconstructible}) requirements.
+the \oldconcept{\-Move\-Constructible} (\tref{cpp17.moveconstructible}) requirements.
 \end{note}
 
 \pnum
@@ -5162,7 +5162,7 @@
 For the overloads in namepace \tcode{std},
 \tcode{pred} shall be an equivalence relation and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveAssignable} requirements (\tref{moveassignable}).
+the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -5262,9 +5262,9 @@
     the \oldconcept{ForwardIterator} requirements and
     its value type is the same as \tcode{T},
     then \tcode{T} shall meet
-    the \oldconcept{CopyAssignable} (\tref{copyassignable}) requirements.
+    the \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
     Otherwise, \tcode{T} shall meet both
-    the \oldconcept{CopyConstructible} (\tref{copyconstructible}) and
+    the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
     \oldconcept{CopyAssignable} requirements.
     \begin{note}
     For the overloads with an \tcode{ExecutionPolicy},
@@ -5412,8 +5412,8 @@
 \tcode{ForwardIterator} shall meet
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -5851,8 +5851,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -5909,8 +5909,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -5979,8 +5979,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -6081,8 +6081,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements},
 the type of \tcode{*result_first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{\-Move\-Assignable} (\tref{moveassignable}) requirements,
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{\-Move\-Assignable} (\tref{cpp17.moveassignable}) requirements,
 and the expression \tcode{*first}
 shall be writable\iref{iterator.requirements.general} to \tcode{result_first}.
 
@@ -6283,8 +6283,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements}, and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -6681,8 +6681,8 @@
 \tcode{BidirectionalIterator} shall meet
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -6964,8 +6964,8 @@
 \tcode{BidirectionalIterator} shall meet
 the \oldconcept{Value\-Swappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7530,8 +7530,8 @@
 shall be a valid heap with respect to \tcode{comp} and \tcode{proj}.
 For the overloads in namespace \tcode{std},
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} requirements (\tref{moveconstructible}) and
-the \oldconcept{MoveAssignable} requirements (\tref{moveassignable}).
+the \oldconcept{MoveConstructible} requirements (\tref{cpp17.moveconstructible}) and
+the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -7583,8 +7583,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConstructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7637,8 +7637,8 @@
 \requires
 For the overloads in namespace \tcode{std},
 the type of \tcode{*first} shall meet
-the \oldconcept{Move\-Constructible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{Move\-Constructible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7690,8 +7690,8 @@
 \tcode{RandomAccessIterator} shall meet
 the \oldconcept{ValueSwappable} requirements\iref{swappable.requirements} and
 the type of \tcode{*first} shall meet
-the \oldconcept{MoveConst\-ruct\-ible} (\tref{moveconstructible}) and
-\oldconcept{MoveAssignable} (\tref{moveassignable}) requirements.
+the \oldconcept{MoveConst\-ruct\-ible} (\tref{cpp17.moveconstructible}) and
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) requirements.
 
 \pnum
 \effects
@@ -7850,7 +7850,7 @@
 \pnum
 \requires
 For the first form, type \tcode{T} shall be
-\oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -7927,7 +7927,7 @@
 \pnum
 \requires
 For the first form, type \tcode{T} shall be
-\oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -8006,7 +8006,7 @@
 \pnum
 \requires
 For the first form, type \tcode{T} shall be
-\oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -8227,7 +8227,7 @@
 \requires
 The value of \tcode{lo} shall be no greater than \tcode{hi}.
 For the first form, type \tcode{T}
-shall be \oldconcept{LessThan\-Comparable} (\tref{lessthancomparable}).
+shall be \oldconcept{LessThan\-Comparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -8805,8 +8805,8 @@
 \pnum
 \requires
 \tcode{T} shall satisfy
-the \oldconcept{CopyConstructible} (\tref{copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{copyassignable}) requirements.
+the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 In the range \crange{first}{last},
 \tcode{binary_op} shall neither modify elements
 nor invalidate iterators or subranges.%
@@ -8908,7 +8908,7 @@
 \requires
 \begin{itemize}
 \item
-  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{moveconstructible}).
+  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}).
 \item
   All of \tcode{binary_op(init, *first)}, \tcode{binary_op(*first, init)},
   \tcode{binary_op(init, init)}, and \tcode{binary_op(*first, *first)}
@@ -8956,8 +8956,8 @@
 \pnum
 \requires
 \tcode{T} shall satisfy
-the \oldconcept{CopyConstructible} (\tref{copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{copyassignable}) requirements.
+the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 In the ranges \crange{first1}{last1} and
 \crange{first2}{first2 + (last1 - first1)}
 \tcode{binary_op1} and \tcode{binary_op2}
@@ -9039,7 +9039,7 @@
 \requires
 \begin{itemize}
 \item
-  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{moveconstructible}).
+  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}).
 \item
   All of
   \begin{itemize}
@@ -9087,7 +9087,7 @@
 \requires
 \begin{itemize}
 \item
-  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{moveconstructible}).
+  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}).
 \item
   All of
   \begin{itemize}
@@ -9225,7 +9225,7 @@
 \requires
 \begin{itemize}
 \item
-  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{moveconstructible}).
+  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}).
 \item
   All of
   \tcode{binary_op(init, init)},
@@ -9328,7 +9328,7 @@
 \begin{itemize}
 \item
   If \tcode{init} is provided,
-  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{moveconstructible});
+  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible});
   otherwise, \tcode{ForwardIterator1}'s value type
   shall be \oldconcept{MoveConstructible}.
 \item
@@ -9403,7 +9403,7 @@
 \requires
 \begin{itemize}
 \item
-  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{moveconstructible}).
+  \tcode{T} shall be \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible}).
 \item
   All of
   \begin{itemize}
@@ -9491,7 +9491,7 @@
 \begin{itemize}
 \item
   If \tcode{init} is provided, \tcode{T} shall be
-  \oldconcept{MoveConstructible} (\tref{moveconstructible});
+  \oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible});
   otherwise, \tcode{ForwardIterator1}'s value type shall be
   \oldconcept{MoveConstructible}.
 \item
@@ -9584,7 +9584,7 @@
 \begin{itemize}
 \item
   For the overloads with no \tcode{ExecutionPolicy},
-  \tcode{T} shall be \oldconcept{MoveAssignable} (\tref{moveassignable}) and
+  \tcode{T} shall be \oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}) and
   shall be constructible from the type of \tcode{*first}.
   \tcode{acc} (defined below) shall be
   writable\iref{iterator.requirements.general}
diff --git a/source/atomics.tex b/source/atomics.tex
index 5e4d152f34..dd0a8aba40 100644
--- a/source/atomics.tex
+++ b/source/atomics.tex
@@ -9,9 +9,9 @@
 
 \pnum
 The following subclauses describe atomics requirements and components for types
-and operations, as summarized in \tref{atomics.lib.summary}.
+and operations, as summarized in \tref{atomics.summary}.
 
-\begin{libsumtab}{Atomics library summary}{tab:atomics.lib.summary}
+\begin{libsumtab}{Atomics library summary}{atomics.summary}
 \ref{atomics.alias} & Type aliases  & \tcode{<atomic>} \\
 \ref{atomics.order} & Order and consistency   &  \\
 \ref{atomics.lockfree}  & Lock-free property   &  \\
@@ -1000,7 +1000,7 @@
 \pnum
 The following operations perform arithmetic computations.
 The key, operator, and computation correspondence is identified
-in \tref{atomic.arithmetic.computations}.
+in \tref{atomic.types.int.comp}.
 
 \indexlibrarymember{fetch_add}{atomic_ref<\placeholder{integral}>}%
 \indexlibrarymember{fetch_and}{atomic_ref<\placeholder{integral}>}%
@@ -1114,7 +1114,7 @@
 \pnum
 The following operations perform arithmetic computations.
 The key, operator, and computation correspondence are identified
-in \tref{atomic.arithmetic.computations}.
+in \tref{atomic.types.int.comp}.
 
 \indexlibrarymember{fetch_add}{atomic_ref<\placeholder{floating-point}>}%
 \indexlibrarymember{fetch_sub}{atomic_ref<\placeholder{floating-point}>}%
@@ -1213,7 +1213,7 @@
 \pnum
 The following operations perform arithmetic computations.
 The key, operator, and computation correspondence is identified
-in \tref{atomic.pointer.computations}.
+in \tref{atomic.types.pointer.comp}.
 
 \indexlibrarymember{fetch_add}{atomic_ref<T*>}%
 \indexlibrarymember{fetch_sub}{atomic_ref<T*>}%
@@ -1849,7 +1849,7 @@
 The following operations perform arithmetic computations. The key, operator, and computation correspondence is:
 
 \begin{floattable}
-{Atomic arithmetic computations}{tab:atomic.arithmetic.computations}{lll|lll}
+{Atomic arithmetic computations}{atomic.types.int.comp}{lll|lll}
 \hline
 \hdstyle{\tcode{\placeholder{key}}}   &
   \hdstyle{Op}                        &
@@ -2020,7 +2020,7 @@
 \pnum
 The following operations perform arithmetic addition and subtraction computations.
 The key, operator, and computation correspondence are identified in
-\tref{atomic.arithmetic.computations}.
+\tref{atomic.types.int.comp}.
 
 \indexlibrary{\idxcode{atomic_fetch_add}}%
 \indexlibrary{\idxcode{atomic_fetch_sub}}%
@@ -2158,7 +2158,7 @@
 and computation correspondence is:
 
 \begin{floattable}
-{Atomic pointer computations}{tab:atomic.pointer.computations}{lll|lll}
+{Atomic pointer computations}{atomic.types.pointer.comp}{lll|lll}
 \hline
 \tcode{Key}       &
   Op          &
diff --git a/source/basic.tex b/source/basic.tex
index 144f2d084a..a84f09678c 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -4568,7 +4568,7 @@
 the largest value of the corresponding unsigned type.
 \end{example}
 
-\begin{floattable}{Minimum width}{tab:width}{ll}
+\begin{floattable}{Minimum width}{basic.fundamental.width}{ll}
 \topline
 \lhdr{Type} & \rhdr{Minimum width $N$} \\
 \capsep
@@ -4581,7 +4581,7 @@
 
 \pnum
 The width of each signed integer type
-shall not be less than the values specified in \tref{width}.
+shall not be less than the values specified in \tref{basic.fundamental.width}.
 The value representation of a signed or unsigned integer type
 comprises $N$ bits, where N is the respective width.
 Each set of values for any padding bits\iref{basic.types}
@@ -4985,10 +4985,10 @@
 \pnum
 There is a partial ordering on cv-qualifiers, so that a type can be
 said to be \defn{more cv-qualified} than another.
-\tref{relations.on.const.and.volatile} shows the relations that
+\tref{basic.type.qualifier.rel} shows the relations that
 constitute this ordering.
 
-\begin{floattable}{Relations on \tcode{const} and \tcode{volatile}}{tab:relations.on.const.and.volatile}
+\begin{floattable}{Relations on \tcode{const} and \tcode{volatile}}{basic.type.qualifier.rel}
 {ccc}
 \topline
 \cvqual{no cv-qualifier}    &<& \tcode{const}           \\
diff --git a/source/classes.tex b/source/classes.tex
index 72dc81ed99..0b9e26bccf 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -3533,7 +3533,7 @@
 
 \begin{importgraphic}
 {Directed acyclic graph}
-{fig:dag}
+{class.dag}
 {figdag.pdf}
 \end{importgraphic}
 \end{note}
@@ -3629,11 +3629,11 @@
 corresponds one-to-one with a distinct \tcode{L} subobject within the
 object of type \tcode{C}. Given the class \tcode{C} defined above, an
 object of class \tcode{C} will have two subobjects of class \tcode{L} as
-shown in Figure~\ref{fig:nonvirt}.
+shown in \fref{class.nonvirt}.
 
 \begin{importgraphic}
 {Non-virtual base}
-{fig:nonvirt}
+{class.nonvirt}
 {fignonvirt.pdf}
 \end{importgraphic}
 
@@ -3659,14 +3659,14 @@
 \end{codeblock}
 \begin{importgraphic}
 {Virtual base}
-{fig:virt}
+{class.virt}
 {figvirt.pdf}
 \end{importgraphic}
 For an object \tcode{c} of class type \tcode{C}, a single subobject of
 type \tcode{V} is shared by every base class subobject of \tcode{c} that has a
 \tcode{virtual} base class of type \tcode{V}. Given the class \tcode{C}
 defined above, an object of class \tcode{C} will have one subobject of
-class \tcode{V}, as shown in Figure~\ref{fig:virt}.
+class \tcode{V}, as shown in \fref{class.virt}.
 \indextext{DAG!multiple inheritance}%
 \indextext{DAG!virtual base class}%
 \end{note}
@@ -3690,14 +3690,14 @@
 \tcode{B} subobject within the object of type \tcode{AA}. Given the
 class \tcode{AA} defined above, class \tcode{AA} has two subobjects of
 class \tcode{B}: \tcode{Z}'s \tcode{B} and the virtual \tcode{B} shared
-by \tcode{X} and \tcode{Y}, as shown in Figure~\ref{fig:virtnonvirt}.
+by \tcode{X} and \tcode{Y}, as shown in \fref{class.virtnonvirt}.
 
 \indextext{DAG!virtual base class}%
 \indextext{DAG!non-virtual base class}%
 \indextext{DAG!multiple inheritance}%
 \begin{importgraphic}
 {Virtual and non-virtual base}
-{fig:virtnonvirt}
+{class.virtnonvirt}
 {figvirtnonvirt.pdf}
 \end{importgraphic}
 \end{note}
@@ -4396,7 +4396,7 @@
 
 \begin{importgraphic}
 {Name lookup}
-{fig:name}
+{class.lookup}
 {figname.pdf}
 \end{importgraphic}
 
diff --git a/source/compatibility.tex b/source/compatibility.tex
index 33e70c15ed..bdcd591c17 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -898,7 +898,7 @@
 \change New keywords.
 \rationale Required for new features.
 \effect
-Added to \tref{keywords}, the following identifiers are new keywords:
+Added to \tref{lex.key}, the following identifiers are new keywords:
 \tcode{alignas},
 \tcode{alignof},
 \tcode{char16_t},
diff --git a/source/concepts.tex b/source/concepts.tex
index 99e3033f9c..0c1f5a981a 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -12,9 +12,9 @@
 \pnum
 The following subclauses describe language-related concepts, comparison
 concepts, object concepts, and callable concepts as summarized in
-\tref{concepts.lib.summary}.
+\tref{concepts.summary}.
 
-\begin{libsumtab}{Fundamental concepts library summary}{tab:concepts.lib.summary}
+\begin{libsumtab}{Fundamental concepts library summary}{concepts.summary}
 \ref{concepts.equality} & Equality preservation     &                    \\ \hline
 \ref{concepts.lang}     & Language-related concepts & \tcode{<concepts>} \\
 \ref{concepts.compare}  & Comparison concepts       &                    \\
@@ -722,7 +722,7 @@
 \begin{itemdescr}
 \pnum
 \begin{note}
-Unlike the \oldconcept{Destructible} requirements~(\tref{destructible}), this
+Unlike the \oldconcept{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/containers.tex b/source/containers.tex
index b2edc1cdd6..d78fb9175a 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -14,9 +14,9 @@
 sequence containers and
 associative containers,
 as summarized in
-\tref{containers.lib.summary}.
+\tref{containers.summary}.
 
-\begin{libsumtab}{Containers library summary}{tab:containers.lib.summary}
+\begin{libsumtab}{Containers library summary}{containers.summary}
 \ref{container.requirements} & Requirements                     &                           \\ \rowsep
 \ref{sequences}              & Sequence containers              &
   \tcode{<array>}, \tcode{<deque>}, \tcode{<forward_list>},
@@ -68,9 +68,9 @@
 \end{note}
 
 \pnum
-In Tables~\ref{tab:containers.container.requirements},
-\ref{tab:containers.reversible.requirements}, and
-\ref{tab:containers.optional.operations}
+In Tables~\ref{tab:container.req},
+\ref{tab:container.rev.req}, and
+\ref{tab:container.opt}
 \tcode{X} denotes a container class containing objects of type
 \tcode{T}, \tcode{a} and \tcode{b}
 denote values of type \tcode{X}, \tcode{u}
@@ -80,7 +80,7 @@
 
 \begin{libreqtab5}
 {Container requirements}
-{tab:containers.container.requirements}
+{container.req}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Operational}  &
 \chdr{Assertion/note}   &   \rhdr{Complexity}   \\
@@ -359,11 +359,11 @@
 the container is called
 \term{reversible}
 and satisfies the additional requirements
-in \tref{containers.reversible.requirements}.
+in \tref{container.rev.req}.
 
 \begin{libreqtab4a}
 {Reversible container requirements}
-{tab:containers.reversible.requirements}
+{container.rev.req}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &
 \chdr{Assertion/note}   &   \rhdr{Complexity}   \\
@@ -459,18 +459,18 @@
 model \libconcept{ContiguousIterator}\iref{iterator.concept.contiguous}.
 
 \pnum
-\tref{containers.optional.operations} lists operations that are provided
+\tref{container.opt} lists operations that are provided
 for some types of containers but not others. Those containers for which the
 listed operations are provided shall implement the semantics described in
-\tref{containers.optional.operations} unless otherwise stated.
+\tref{container.opt} unless otherwise stated.
 If the iterators passed to \tcode{lexicographical_compare}
 satisfy the constexpr iterator requirements\iref{iterator.requirements.general}
-then the operations described in \tref{containers.optional.operations}
+then the operations described in \tref{container.opt}
 are implemented by constexpr functions.
 
 \begin{libreqtab5}
 {Optional container operations}
-{tab:containers.optional.operations}
+{container.opt}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Operational}  &
 \chdr{Assertion/note}   &   \rhdr{Complexity}   \\
@@ -515,7 +515,7 @@
 \pnum
 All of the containers defined in this Clause and in~\ref{basic.string} except \tcode{array}
 meet the additional requirements of an allocator-aware container, as described in
-\tref{containers.allocatoraware}.
+\tref{container.alloc.req}.
 
 Given an allocator type \tcode{A}
 and given a container type \tcode{X} having a \tcode{value_type} identical to \tcode{T}
@@ -600,7 +600,7 @@
 \end{note}
 
 \pnum
-In \tref{containers.allocatoraware}, \tcode{X} denotes an allocator-aware container class
+In \tref{container.alloc.req}, \tcode{X} denotes an allocator-aware container class
 with a \tcode{value_type} of \tcode{T} using allocator of type \tcode{A}, \tcode{u} denotes a
 variable,
 \tcode{a} and \tcode{b} denote non-const lvalues of type \tcode{X},
@@ -609,7 +609,7 @@
 
 \begin{libreqtab4a}
 {Allocator-aware container requirements}
-{tab:containers.allocatoraware}
+{container.alloc.req}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &
 \chdr{Assertion/note}   &   \rhdr{Complexity}   \\
@@ -780,8 +780,8 @@
 \end{note}
 
 \pnum
-In Tables~\ref{tab:containers.sequence.requirements}
-and \ref{tab:containers.sequence.optional},
+In Tables~\ref{tab:container.seq.req}
+and \ref{tab:container.seq.opt},
 \tcode{X} denotes a sequence container class,
 \tcode{a} denotes a value of type \tcode{X} containing elements of type \tcode{T},
 \tcode{u} denotes the name of a variable being declared,
@@ -814,7 +814,7 @@
 
 \begin{libreqtab3}
 {Sequence container requirements (in addition to container)}
-{tab:containers.sequence.requirements}
+{container.seq.req}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \rhdr{Assertion/note}       \\
                         &                       &   \rhdr{pre-/post-condition}   \\ \capsep
@@ -1043,7 +1043,7 @@
 \end{itemize}
 
 \pnum
-\tref{containers.sequence.optional} lists operations
+\tref{container.seq.opt} lists operations
 that are provided for some types of
 sequence containers but not others.
 An implementation shall provide
@@ -1053,7 +1053,7 @@
 
 \begin{libreqtab4a}
 {Optional sequence container operations}
-{tab:containers.sequence.optional}
+{container.seq.opt}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Operational semantics}       &   \rhdr{Container}    \\ \capsep
 \endfirsthead
@@ -1214,9 +1214,9 @@
 ownership to another container with compatible nodes.  Containers with
 compatible nodes have the same node handle type. Elements may be transferred in
 either direction between container types in the same row of
-\tref{containers.node.compat}.
+\tref{container.node.compat}.
 
-\begin{floattable}{Container types with compatible nodes}{tab:containers.node.compat}
+\begin{floattable}{Container types with compatible nodes}{container.node.compat}
 {ll}
 \topline
 \tcode{map<K, T, C1, A>}               & \tcode{map<K, T, C2, A>}                    \\
@@ -1255,7 +1255,7 @@
 template<@\unspecnc@>
 class @\placeholder{node-handle}@ {
 public:
-  // These type declarations are described in Tables \ref{tab:containers.associative.requirements} and \ref{tab:HashRequirements}.
+  // These type declarations are described in Tables \ref{tab:container.assoc.req} and \ref{tab:container.hash.req}.
   using value_type     = @\seebelownc{}@;     // not present for map containers
   using key_type       = @\seebelownc{}@;     // not present for set containers
   using mapped_type    = @\seebelownc{}@;     // not present for set containers
@@ -1578,18 +1578,18 @@
 The associative containers meet all the requirements of Allocator-aware
 containers\iref{container.requirements.general}, except that for
 \tcode{map} and \tcode{multimap}, the requirements placed on \tcode{value_type}
-in \tref{containers.allocatoraware} apply instead to \tcode{key_type}
+in \tref{container.alloc.req} apply instead to \tcode{key_type}
 and \tcode{mapped_type}. \begin{note} For example, in some cases \tcode{key_type} and \tcode{mapped_type}
 are required to be \oldconcept{CopyAssignable} even though the associated
 \tcode{value_type}, \tcode{pair<const key_type, mapped_type>}, is not
 \oldconcept{CopyAssignable}. \end{note}
 
 \pnum
-In \tref{containers.associative.requirements},
+In \tref{container.assoc.req},
 \tcode{X} denotes an associative container class,
 \tcode{a} denotes a value of type \tcode{X},
 \tcode{a2} denotes a value of a type with nodes compatible with type
-\tcode{X} (\tref{containers.node.compat}),
+\tcode{X} (\tref{container.node.compat}),
 \tcode{b} denotes a possibly \tcode{const} value of type \tcode{X},
 \tcode{u} denotes the name of a variable being declared,
 \tcode{a_uniq} denotes a value of type \tcode{X}
@@ -1636,7 +1636,7 @@
 
 \begin{libreqtab4b}
 {Associative container requirements (in addition to container)}
-{tab:containers.associative.requirements}
+{container.assoc.req}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Assertion/note}       &   \rhdr{Complexity}   \\
                         &                       &   \chdr{pre-/post-condition}   &                       \\ \capsep
@@ -2248,7 +2248,7 @@
 The unordered associative containers meet all the requirements of Allocator-aware
 containers\iref{container.requirements.general}, except that for
 \tcode{unordered_map} and \tcode{unordered_multimap}, the requirements placed on \tcode{value_type}
-in \tref{containers.allocatoraware} apply instead to \tcode{key_type}
+in \tref{container.alloc.req} apply instead to \tcode{key_type}
 and \tcode{mapped_type}. \begin{note} For example, \tcode{key_type} and \tcode{mapped_type}
 are sometimes required to be \oldconcept{CopyAssignable} even though the associated
 \tcode{value_type}, \tcode{pair<const key_type, mapped_type>}, is not
@@ -2261,12 +2261,12 @@
 \indextext{unordered associative containers!unique keys}%
 \indextext{unordered associative containers!equivalent keys}%
 \indextext{requirements!container}%
-In \tref{HashRequirements}:
+In \tref{container.hash.req}:
 \begin{itemize}
 \item \tcode{X} denotes an unordered associative container class,
 \item \tcode{a} denotes a value of type \tcode{X},
 \item \tcode{a2} denotes a value of a type with nodes compatible
-  with type \tcode{X} (\tref{containers.node.compat}),
+  with type \tcode{X} (\tref{container.node.compat}),
 \item \tcode{b} denotes a possibly const value of type \tcode{X},
 \item \tcode{a_uniq} denotes a value of type \tcode{X}
   when \tcode{X} supports unique keys,
@@ -2312,7 +2312,7 @@
 
 \begin{libreqtab4d}
   {Unordered associative container requirements (in addition to container)}
-  {tab:HashRequirements}
+  {container.hash.req}
 \\ \topline
 \lhdr{Expression} & \chdr{Return type}   & \chdr{Assertion/note}      & \rhdr{Complexity} \\
                   &                      & \chdr{pre-/post-condition} & \\ \capsep
@@ -2506,7 +2506,7 @@
 \tcode{X(b)}\br \tcode{X a(b);}
 &   \tcode{X}
 &   Copy constructor.  In addition to the requirements
-    of \tref{containers.container.requirements}, copies the
+    of \tref{container.req}, copies the
   hash function, predicate, and maximum load factor.
 &   Average case linear in \tcode{b.size()}, worst case quadratic.
 \\ \rowsep
@@ -2514,7 +2514,7 @@
 \tcode{a = b}
 &   \tcode{X\&}
 &   Copy assignment operator.  In addition to the
-    requirements of \tref{containers.container.requirements}, copies
+    requirements of \tref{container.req}, copies
   the hash function, predicate, and maximum load factor.
 &   Average case linear in \tcode{b.size()}, worst case quadratic.
 \\ \rowsep
@@ -3625,7 +3625,7 @@
 \tcode{deque}
 satisfies all of the requirements of a container, of a reversible container
 (given in tables in~\ref{container.requirements}), of a sequence container,
-including the optional sequence container requirements\iref{sequence.reqmts}, and of an allocator-aware container (\tref{containers.allocatoraware}).
+including the optional sequence container requirements\iref{sequence.reqmts}, and of an allocator-aware container (\tref{container.alloc.req}).
 Descriptions are provided here only for operations on
 \tcode{deque}
 that are not described in one of these tables
@@ -4017,13 +4017,13 @@
 
 \pnum
 A \tcode{forward_list} satisfies all of the requirements of a container
-(\tref{containers.container.requirements}), except that the \tcode{size()}
+(\tref{container.req}), except that the \tcode{size()}
 member function is not provided and \tcode{operator==} has linear complexity.
 A \tcode{forward_list} also satisfies all of the requirements for an allocator-aware
-container (\tref{containers.allocatoraware}). In addition, a \tcode{forward_list}
+container (\tref{container.alloc.req}). In addition, a \tcode{forward_list}
 provides the \tcode{assign} member functions
-(\tref{containers.sequence.requirements}) and several of the optional
-container requirements (\tref{containers.sequence.optional}).
+(\tref{container.seq.req}) and several of the optional
+container requirements (\tref{container.seq.opt}).
 Descriptions are provided here only for operations on
 \tcode{forward_list} that are not described in that table or for operations where there
 is additional semantic information.
@@ -4734,7 +4734,7 @@
 \ref{container.requirements}), of a sequence container,
 including most of the optional sequence container
 requirements\iref{sequence.reqmts}, and of an allocator-aware container
-(\tref{containers.allocatoraware}).
+(\tref{container.alloc.req}).
 The exceptions are the
 \tcode{operator[]}
 and
@@ -5424,7 +5424,7 @@
 reversible container (given in two tables in~\ref{container.requirements}), of a
 sequence container, including most of the optional sequence container
 requirements\iref{sequence.reqmts}, of an allocator-aware container
-(\tref{containers.allocatoraware}),
+(\tref{container.alloc.req}),
 and, for an element type other than \tcode{bool},
 of a contiguous container\iref{container.requirements.general}.
 The exceptions are the
@@ -6300,7 +6300,7 @@
 A
 \tcode{map}
 satisfies all of the requirements of a container, of a reversible container\iref{container.requirements}, of
-an associative container\iref{associative.reqmts}, and of an allocator-aware container (\tref{containers.allocatoraware}).
+an associative container\iref{associative.reqmts}, and of an allocator-aware container (\tref{container.alloc.req}).
 A
 \tcode{map}
 also provides most operations described in~\ref{associative.reqmts}
@@ -6848,7 +6848,7 @@
 \tcode{multimap} satisfies all of the requirements of a container and of a
 reversible container\iref{container.requirements}, of an associative
 container\iref{associative.reqmts}, and of an allocator-aware container
-(\tref{containers.allocatoraware}).
+(\tref{container.alloc.req}).
 A
 \tcode{multimap}
 also provides most operations described in~\ref{associative.reqmts}
@@ -7169,7 +7169,7 @@
 A \tcode{set} satisfies all of the requirements of a container, of a reversible
 container\iref{container.requirements}, of an associative
 container\iref{associative.reqmts}, and of an allocator-aware container
-(\tref{containers.allocatoraware}).
+(\tref{container.alloc.req}).
 A
 \tcode{set}
 also provides most operations described in~\ref{associative.reqmts}
@@ -7448,7 +7448,7 @@
 A \tcode{multiset} satisfies all of the requirements of a container, of a
 reversible container\iref{container.requirements}, of an associative
 container\iref{associative.reqmts}, and of an allocator-aware container
-(\tref{containers.allocatoraware}).
+(\tref{container.alloc.req}).
 \tcode{multiset}
 also provides most operations described in~\ref{associative.reqmts}
 for duplicate keys.
@@ -7880,7 +7880,7 @@
 supports forward iterators.
 
 \pnum
-An \tcode{unordered_map} satisfies all of the requirements of a container, of an unordered associative container, and of an allocator-aware container (\tref{containers.allocatoraware}). It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_map} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_map<Key, T>} the \tcode{key type} is \tcode{Key}, the mapped type is \tcode{T}, and the value type is \tcode{pair<const Key, T>}.
+An \tcode{unordered_map} satisfies all of the requirements of a container, of an unordered associative container, and of an allocator-aware container (\tref{container.alloc.req}). It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_map} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_map<Key, T>} the \tcode{key type} is \tcode{Key}, the mapped type is \tcode{T}, and the value type is \tcode{pair<const Key, T>}.
 
 \pnum
 This subclause only describes operations on \tcode{unordered_map} that
@@ -8482,7 +8482,7 @@
 \pnum
 An \tcode{unordered_multimap} satisfies all of the requirements of a container, of an
 unordered associative container, and of an allocator-aware container
-(\tref{containers.allocatoraware}). It provides the operations described in the
+(\tref{container.alloc.req}). It provides the operations described in the
 preceding requirements table for equivalent keys; that is, an \tcode{unordered_multimap}
 supports the \tcode{a_eq} operations in that table, not the \tcode{a_uniq} operations.
 For an \tcode{unordered_multimap<Key, T>} the \tcode{key type} is \tcode{Key}, the
@@ -8869,7 +8869,7 @@
 supports forward iterators.
 
 \pnum
-An \tcode{unordered_set} satisfies all of the requirements of a container, of an unordered associative container, and of an allocator-aware container (\tref{containers.allocatoraware}). It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_set} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_set<Key>} the \tcode{key type} and the value type are both \tcode{Key}. The \tcode{iterator} and \tcode{const_iterator} types are both constant iterator types. It is unspecified whether they are the same type.
+An \tcode{unordered_set} satisfies all of the requirements of a container, of an unordered associative container, and of an allocator-aware container (\tref{container.alloc.req}). It provides the operations described in the preceding requirements table for unique keys; that is, an \tcode{unordered_set} supports the \tcode{a_uniq} operations in that table, not the \tcode{a_eq} operations. For an \tcode{unordered_set<Key>} the \tcode{key type} and the value type are both \tcode{Key}. The \tcode{iterator} and \tcode{const_iterator} types are both constant iterator types. It is unspecified whether they are the same type.
 
 \pnum
 This subclause only describes operations on \tcode{unordered_set} that
@@ -9207,7 +9207,7 @@
 \pnum
 An \tcode{unordered_multiset} satisfies all of the requirements of a container, of an
 unordered associative container, and of an allocator-aware container
-(\tref{containers.allocatoraware}). It provides the operations described in the
+(\tref{container.alloc.req}). It provides the operations described in the
 preceding requirements table for equivalent keys; that is, an \tcode{unordered_multiset}
 supports the \tcode{a_eq} operations in that table, not the \tcode{a_uniq} operations.
 For an \tcode{unordered_multiset<Key>} the \tcode{key type} and the value type are
diff --git a/source/declarations.tex b/source/declarations.tex
index 48a873a32d..ed81cea0a0 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1349,14 +1349,14 @@
 specify either a previously-declared type, a type determined from an
 expression, or one of the
 fundamental types\iref{basic.fundamental}.
-\tref{simple.type.specifiers}
+\tref{dcl.type.simple}
  summarizes the valid combinations of
 \grammarterm{simple-type-specifier}{s}
 and the types they specify.
 
 \begin{simpletypetable}
 {\grammarterm{simple-type-specifier}{s} and the types they specify}
-{tab:simple.type.specifiers}
+{dcl.type.simple}
 {ll}
 \topline
 \hdstyle{Specifier(s)}            &   \hdstyle{Type}                  \\ \capsep
diff --git a/source/diagnostics.tex b/source/diagnostics.tex
index 1cc9dd3e3f..63dfcbd9d2 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -12,9 +12,9 @@
 reporting several kinds of exceptional conditions,
 documenting program assertions, and
 a global variable for error number codes,
-as summarized in \tref{diagnostics.lib.summary}.
+as summarized in \tref{diagnostics.summary}.
 
-\begin{libsumtab}{Diagnostics library summary}{tab:diagnostics.lib.summary}
+\begin{libsumtab}{Diagnostics library summary}{diagnostics.summary}
 \ref{std.exceptions}  & Exception classes     &   \tcode{<stdexcept>}     \\ \rowsep
 \ref{assertions}      & Assertions            &   \tcode{<cassert>}       \\ \rowsep
 \ref{errno}           & Error numbers         &   \tcode{<cerrno>}        \\ \rowsep
diff --git a/source/expressions.tex b/source/expressions.tex
index ce51f9526a..c46ebfa61e 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -128,11 +128,11 @@
 
 \rSec2[basic.lval]{Value category}
 \pnum
-Expressions are categorized according to the taxonomy in Figure~\ref{fig:categories}.
+Expressions are categorized according to the taxonomy in \fref{basic.lval}.
 
 \begin{importgraphic}
 {Expression category taxonomy}
-{fig:categories}
+{basic.lval}
 {valuecategories.pdf}
 \end{importgraphic}
 
diff --git a/source/future.tex b/source/future.tex
index ce84a9fe7f..6f97e9c3f0 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -109,9 +109,9 @@
 For compatibility with the
 \indextext{library!C standard}%
 C standard library, the \Cpp{} standard library provides
-the \defnx{C headers}{headers!C library} shown in \tref{future.c.headers}.
+the \defnx{C headers}{headers!C library} shown in \tref{depr.c.headers}.
 
-\begin{multicolfloattable}{C headers}{tab:future.c.headers}
+\begin{multicolfloattable}{C headers}{depr.c.headers}
 {lllll}
 \tcode{<assert.h>} \\
 \tcode{<complex.h>} \\
@@ -315,7 +315,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{EqualityComparable} (\tref{equalitycomparable}).
+Type \tcode{T} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}).
 
 \pnum
 \returns
@@ -330,7 +330,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -345,7 +345,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -360,7 +360,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -514,10 +514,10 @@
 \tcode{strstreambuf},
 initializing the base class with
 \tcode{streambuf()}.
-The postconditions of this function are indicated in \tref{future.strstreambuf.effects}.
+The postconditions of this function are indicated in \tref{depr.strstreambuf.cons.sz}.
 \end{itemdescr}
 
-\begin{libtab2}{\tcode{strstreambuf(streamsize)} effects}{tab:future.strstreambuf.effects}
+\begin{libtab2}{\tcode{strstreambuf(streamsize)} effects}{depr.strstreambuf.cons.sz}
 {ll}
 {Element}{Value}
 \tcode{strmode}	&	\tcode{dynamic}		\\
@@ -538,10 +538,10 @@
 \tcode{strstreambuf},
 initializing the base class with
 \tcode{streambuf()}.
-The postconditions of this function are indicated in \tref{future.strstreambuf1.effects}.
+The postconditions of this function are indicated in \tref{depr.strstreambuf.cons.alloc}.
 
 \begin{libtab2}{\tcode{strstreambuf(void* (*)(size_t), void (*)(void*))} effects}
-{tab:future.strstreambuf1.effects}
+{depr.strstreambuf.cons.alloc}
 {ll}
 {Element}{Value}
 \tcode{strmode}	&	\tcode{dynamic}			\\
@@ -568,10 +568,10 @@
 \tcode{strstreambuf},
 initializing the base class with
 \tcode{streambuf()}.
-The postconditions of this function are indicated in \tref{future.strstreambuf2.effects}.
+The postconditions of this function are indicated in \tref{depr.strstreambuf.cons.ptr}.
 
 \begin{libtab2}{\tcode{strstreambuf(charT*, streamsize, charT*)} effects}
-{tab:future.strstreambuf2.effects}
+{depr.strstreambuf.cons.ptr}
 {ll}
 {Element}{Value}
 \tcode{strmode}	&	0						\\
@@ -897,9 +897,9 @@
 \pnum
 \effects
 Alters the stream position within one of the
-controlled sequences, if possible, as indicated in \tref{future.seekoff.positioning}.
+controlled sequences, if possible, as indicated in \tref{depr.strstreambuf.seekoff.pos}.
 
-\begin{libtab2}{\tcode{seekoff} positioning}{tab:future.seekoff.positioning}
+\begin{libtab2}{\tcode{seekoff} positioning}{depr.strstreambuf.seekoff.pos}
 {p{2.5in}l}{Conditions}{Result}
 \tcode{(which \& ios::in) != 0}	&
  positions the input sequence	\\ \rowsep
@@ -919,9 +919,9 @@
 For a sequence to be positioned, if its next pointer is a null pointer,
 the positioning operation fails.
 Otherwise, the function determines \tcode{newoff} as indicated in
-\tref{future.newoff.values}.
+\tref{depr.strstreambuf.seekoff.newoff}.
 
-\begin{libtab2}{\tcode{newoff} values}{tab:future.newoff.values}
+\begin{libtab2}{\tcode{newoff} values}{depr.strstreambuf.seekoff.newoff}
 {p{2.0in}p{2.0in}}{Condition}{\tcode{newoff} Value}
 \tcode{way == ios::beg}	&
  0	\\ \rowsep
@@ -2340,7 +2340,7 @@
 \pnum
 The \tcode{ctype} locale category includes the following facets
 as if they were specified
-in table \tref{localization.category.facets} of \ref{locale.category}.
+in table \tref{locale.category.facets} of \ref{locale.category}.
 
 \begin{codeblock}
 codecvt<char16_t, char, mbstate_t>
@@ -2350,7 +2350,7 @@
 \pnum
 The \tcode{ctype} locale category includes the following facets
 as if they were specified
-in table \tref{localization.required.specializations} of \ref{locale.category}.
+in table \tref{locale.spec} of \ref{locale.category}.
 
 \begin{codeblock}
 codecvt_byname<char16_t, char, mbstate_t>
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 5917ac734e..b856b81bbd 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -18,9 +18,9 @@
 stream formatting and manipulators,
 string streams,
 and file streams,
-as summarized in \tref{iostreams.lib.summary}.
+as summarized in \tref{iostreams.summary}.
 
-\begin{libsumtab}{Input/output library summary}{tab:iostreams.lib.summary}
+\begin{libsumtab}{Input/output library summary}{iostreams.summary}
 \ref{iostreams.requirements}  & Requirements                &                      \\ \rowsep
 \ref{iostream.forward}        & Forward declarations        & \tcode{<iosfwd>}     \\ \rowsep
 \ref{iostream.objects}        & Standard iostream objects   & \tcode{<iostream>}   \\ \rowsep
@@ -37,16 +37,18 @@
 \end{libsumtab}
 
 \pnum
-Figure~\ref{fig:streampos} illustrates relationships among various types
+\begin{note}
+\fref{iostreams.streampos} illustrates relationships among various types
 described in this clause. A line from \textbf{A} to \textbf{B} indicates that \textbf{A}
 is an alias (e.g., a typedef) for \textbf{B} or that \textbf{A} is defined in terms of
 \textbf{B}.
 
 \begin{importgraphic}
-{Stream position, offset, and size types [non-normative]}
-{fig:streampos}
+{Stream position, offset, and size types}
+{iostreams.streampos}
 {figstreampos.pdf}
 \end{importgraphic}
+\end{note}
 
 \rSec1[iostreams.requirements]{Iostreams requirements}
 
@@ -963,9 +965,9 @@
 The type
 \tcode{fmtflags}
 is a bitmask type\iref{bitmask.types}.
-Setting its elements has the effects indicated in \tref{iostreams.fmtflags.effects}.
+Setting its elements has the effects indicated in \tref{ios.fmtflags}.
 
-\begin{libefftab}{\tcode{fmtflags} effects}{tab:iostreams.fmtflags.effects}
+\begin{libefftab}{\tcode{fmtflags} effects}{ios.fmtflags}
 \tcode{boolalpha} &
  insert and extract \tcode{bool} type in alphabetic format\\
 \tcode{dec}     &
@@ -1002,9 +1004,9 @@
 \pnum
 Type
 \tcode{fmtflags}
-also defines the constants indicated in \tref{iostreams.fmtflags.constants}.
+also defines the constants indicated in \tref{ios.fmtflags.const}.
 
-\begin{floattable}{\tcode{fmtflags} constants}{tab:iostreams.fmtflags.constants}
+\begin{floattable}{\tcode{fmtflags} constants}{ios.fmtflags.const}
 {ll}
 \topline
 \lhdr{Constant}   & \rhdr{Allowable values}       \\ \capsep
@@ -1026,9 +1028,9 @@
 The type
 \tcode{iostate}
 is a bitmask type\iref{bitmask.types}
-that contains the elements indicated in \tref{iostreams.iostate.effects}.
+that contains the elements indicated in \tref{ios.iostate}.
 
-\begin{libefftab}{\tcode{iostate} effects}{tab:iostreams.iostate.effects}
+\begin{libefftab}{\tcode{iostate} effects}{ios.iostate}
 \tcode{badbit}    &
  indicates a loss of integrity in an input or output sequence
  (such as an irrecoverable read error from a file); \\
@@ -1062,9 +1064,9 @@
 The type
 \tcode{openmode}
 is a bitmask type\iref{bitmask.types}.
-It contains the elements indicated in \tref{iostreams.openmode.effects}.
+It contains the elements indicated in \tref{ios.openmode}.
 
-\begin{libefftab}{\tcode{openmode} effects}{tab:iostreams.openmode.effects}
+\begin{libefftab}{\tcode{openmode} effects}{ios.openmode}
 \tcode{app}     &
  seek to end before each write  \\
 \tcode{ate}     &
@@ -1092,9 +1094,9 @@
 The type
 \tcode{seekdir}
 is an enumerated type\iref{enumerated.types}
-that contains the elements indicated in \tref{iostreams.seekdir.effects}.
+that contains the elements indicated in \tref{ios.seekdir}.
 
-\begin{libefftabmean}{\tcode{seekdir} effects}{tab:iostreams.seekdir.effects}
+\begin{libefftabmean}{\tcode{seekdir} effects}{ios.seekdir}
 \tcode{beg}     &
  request a seek (for subsequent input or output) relative to the beginning of the stream  \\
 \tcode{cur}     &
@@ -1669,10 +1671,10 @@
 It holds a state object
 whose type is equal to the template parameter \tcode{stateT}.
 Type \tcode{stateT} shall meet
-the \oldconcept{DefaultConstructible} (\tref{defaultconstructible}),
-\oldconcept{CopyConstructible} (\tref{copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{copyassignable}), and
-\oldconcept{Destructible} (\tref{destructible}) requirements.
+the \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
+\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}), and
+\oldconcept{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<stateT>} is \tcode{true},
@@ -1684,8 +1686,8 @@
 \oldconcept{CopyConstructible},
 \oldconcept{CopyAssignable},
 \oldconcept{Destructible},
-and \oldconcept{EqualityComparable} (\tref{equalitycomparable}) requirements.
-In addition, the expressions shown in \tref{iostreams.position.requirements}
+and \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+In addition, the expressions shown in \tref{fpos.operations}
 are valid and have the indicated semantics.
 In that table,
 \begin{itemize}
@@ -1700,7 +1702,7 @@
 
 \begin{libreqtab4c}
 {Position type requirements}
-{tab:iostreams.position.requirements}
+{fpos.operations}
 \\ \topline
 \lhdr{Expression}   & \chdr{Return type}  & \chdr{Operational}  & \rhdr{Assertion/note}   \\
             &           & \chdr{semantics}  & \rhdr{pre-/post-condition} \\ \capsep
@@ -1898,9 +1900,9 @@
 \begin{itemdescr}
 \pnum
 \ensures
-The postconditions of this function are indicated in \tref{iostreams.basicios.init.effects}.
+The postconditions of this function are indicated in \tref{basic.ios.cons}.
 
-\begin{libefftabvalue}{\tcode{basic_ios::init()} effects}{tab:iostreams.basicios.init.effects}
+\begin{libefftabvalue}{\tcode{basic_ios::init()} effects}{basic.ios.cons}
 \tcode{rdbuf()}   &
  \tcode{sb}     \\
 \tcode{tie()}   &
@@ -2121,11 +2123,10 @@
 
 \pnum
 \ensures
-The postconditions of this function are indicated in \tref{iostreams.copyfmt.effects}.
-
+The postconditions of this function are indicated in \tref{basic.ios.copyfmt}.
 
 \begin{LibEffTab}{\tcode{basic_ios::copyfmt()} effects}
-{tab:iostreams.copyfmt.effects}{Value}{1.2in}
+{basic.ios.copyfmt}{Value}{1.2in}
 \tcode{rdbuf()}             &
   \textit{unchanged}        \\
 \tcode{tie()}               &
@@ -7781,9 +7782,9 @@
 \pnum
 \effects
 Alters the stream position within one of the
-controlled sequences, if possible, as indicated in \tref{iostreams.seekoff.positioning}.
+controlled sequences, if possible, as indicated in \tref{stringbuf.seekoff.pos}.
 
-\begin{libtab2}{\tcode{seekoff} positioning}{tab:iostreams.seekoff.positioning}
+\begin{libtab2}{\tcode{seekoff} positioning}{stringbuf.seekoff.pos}
 {p{2.5in}l}{Conditions}{Result}
 \tcode{(which \& ios_base::in)}\tcode{ == ios_base::in}  &
  positions the input sequence \\ \rowsep
@@ -7804,7 +7805,7 @@
 \pnum
 For a sequence to be positioned,
 the function determines \tcode{newoff} as indicated in
-\tref{iostreams.newoff.values}.
+\tref{stringbuf.seekoff.newoff}.
 If the sequence's next pointer
 (either
 \tcode{gptr()}
@@ -7813,7 +7814,7 @@
 is a null pointer and \tcode{newoff} is nonzero,
 the positioning operation fails.
 
-\begin{libtab2}{\tcode{newoff} values}{tab:iostreams.newoff.values}
+\begin{libtab2}{\tcode{newoff} values}{stringbuf.seekoff.newoff}
 {lp{2.0in}}{Condition}{\tcode{newoff} Value}
 \tcode{way == ios_base::beg}  &
  0  \\ \rowsep
@@ -8785,11 +8786,11 @@
 \indexlibrary{\idxcode{fopen}}%
 with the second argument determined from
 \tcode{mode \& \~{}ios_base::ate}
-as indicated in \tref{iostreams.file.open.modes}.
+as indicated in \tref{filebuf.open.modes}.
 If \tcode{mode} is not some combination of flags shown in the table then
 the open fails.
 
-\begin{floattable}{File open modes}{tab:iostreams.file.open.modes}
+\begin{floattable}{File open modes}{filebuf.open.modes}
 {cccccl}
 \topline
 \multicolumn{5}{|c}{\tcode{ios_base} flag combination} & \tcode{stdio} equivalent \\
@@ -9174,9 +9175,9 @@
 The function determines one of three values for the
 argument \tcode{whence}, of type
 \tcode{int},
-as indicated in \tref{iostreams.seekoff.effects}.
+as indicated in \tref{filebuf.seekoff}.
 
-\begin{libtab2}{\tcode{seekoff} effects}{tab:iostreams.seekoff.effects}
+\begin{libtab2}{\tcode{seekoff} effects}{filebuf.seekoff}
 {ll}{\tcode{way} Value}{\tcode{stdio} Equivalent}
 \tcode{basic_ios::beg}  & \tcode{SEEK_SET}  \\
 \tcode{basic_ios::cur}  & \tcode{SEEK_CUR}  \\
@@ -10193,7 +10194,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Move constructs from \tcode{other} (\tref{moveconstructible}).
+Move constructs from \tcode{other} (\tref{cpp17.moveconstructible}).
 
 \pnum
 \ensures
@@ -10458,7 +10459,7 @@
 
 \pnum
 \tcode{Allocator} shall satisfy the \oldconcept{Allocator} requirements
-(\tref{utilities.allocator.requirements}).
+(\tref{cpp17.allocator}).
 
 \pnum
 \begin{example}
@@ -10801,7 +10802,7 @@
 
 \pnum
 Template parameters named \tcode{Allocator} shall satisfy the
-\oldconcept{Allocator} requirements (\tref{utilities.allocator.requirements}).
+\oldconcept{Allocator} requirements (\tref{cpp17.allocator}).
 
 \rSec3[fs.req.namespace]{Namespaces and headers}
 
@@ -12983,10 +12984,10 @@
 
 \pnum
 This enum specifies constants used to identify the format of the character
-sequence, with the meanings listed in \tref{enum.path.format}.
+sequence, with the meanings listed in \tref{fs.enum.path.format}.
 
 \begin{floattable}
-{Enum \tcode{path::format}}{tab:enum.path.format}{lp{4in}}
+{Enum \tcode{path::format}}{fs.enum.path.format}{lp{4in}}
 \topline
 \lhdr{Name} & \rhdr{Meaning} \\\capsep
 \tcode{native_format} & The native pathname format. \\\rowsep
@@ -13011,7 +13012,7 @@
 The values of the constants are distinct.
 
 \begin{floattable}
-{Enum class \tcode{file_type}}{tab:fs.enum.file.type}
+{Enum class \tcode{file_type}}{fs.enum.file.type}
 {lp{4.5in}}
 \topline
 \lhdr{Constant}	&
@@ -13050,14 +13051,14 @@
 \pnum
 The \tcode{enum class} type \tcode{copy_options}
 is a bitmask type\iref{bitmask.types} that specifies bitmask constants used to control the semantics of
-copy operations. The constants are specified in option groups with the meanings listed in \tref{fs.enum.copy_options}.
+copy operations. The constants are specified in option groups with the meanings listed in \tref{fs.enum.copy.opts}.
 The constant \tcode{none} represents the empty bitmask, and
 is shown in each option group for purposes of exposition;
 implementations shall provide only a single definition.
 Every other constant in the table represents a distinct bitmask element.
 
 \begin{floattable}
-{Enum class \tcode{copy_options}}{tab:fs.enum.copy_options}
+{Enum class \tcode{copy_options}}{fs.enum.copy.opts}
 {lp{4in}}
 \topline
 \ohdrx{2}{Option group controlling \tcode{copy_file} function effects for existing target files} \\ \rowsep
@@ -13110,7 +13111,7 @@
 permissions, with the meanings listed in \tref{fs.enum.perms}.
 
 \begin{floattable}
-{Enum class \tcode{perms}}{tab:fs.enum.perms}
+{Enum class \tcode{perms}}{fs.enum.perms}
 {lrlp{3.2in}}
 \topline
 \lhdr{Name}	& \chdr{Value}		& \chdr{POSIX}	& \rhdr{Definition or notes}	\\
@@ -13167,13 +13168,13 @@
 The \tcode{enum class} type \tcode{perm_options}
 is a bitmask type\iref{bitmask.types} that specifies bitmask constants used to
 control the semantics of permissions operations,
-with the meanings listed in \tref{enum.perm_options}.
+with the meanings listed in \tref{fs.enum.perm.opts}.
 The bitmask constants are bitmask elements.
-In \tref{enum.perm_options} \tcode{perm} denotes a value of type \tcode{perms}
+In \tref{fs.enum.perm.opts} \tcode{perm} denotes a value of type \tcode{perms}
 passed to \tcode{permissions}.
 
 \begin{floattable}
-{Enum class \tcode{perm_options}}{tab:enum.perm_options}{x{.15\hsize}x{.70\hsize}}
+{Enum class \tcode{perm_options}}{fs.enum.perm.opts}{x{.15\hsize}x{.70\hsize}}
 \topline
 \lhdr{Name} &
   \rhdr{Meaning} \\ \capsep
@@ -13197,12 +13198,12 @@
 \pnum
 The \tcode{enum class} type \tcode{directory_options} is a bitmask
   type\iref{bitmask.types} that specifies bitmask constants used to identify
-  directory traversal options, with the meanings listed in \tref{fs.enum.directory_options}.
+  directory traversal options, with the meanings listed in \tref{fs.enum.dir.opts}.
   The constant \tcode{none} represents the empty bitmask;
   every other constant in the table represents a distinct bitmask element.
 
 \begin{floattable}
-{Enum class \tcode{directory_options}}{tab:fs.enum.directory_options}
+{Enum class \tcode{directory_options}}{fs.enum.dir.opts}
 {lp{3in}}
 \topline
 \lhdr{Name}	&
diff --git a/source/iterators.tex b/source/iterators.tex
index 43ecd9e7f6..976e3099c9 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -17,9 +17,9 @@
 iterator primitives,
 predefined iterators,
 and stream iterators,
-as summarized in \tref{iterators.lib.summary}.
+as summarized in \tref{iterators.summary}.
 
-\begin{libsumtab}{Iterators library summary}{tab:iterators.lib.summary}
+\begin{libsumtab}{Iterators library summary}{iterators.summary}
 \ref{iterator.requirements} & Iterator requirements     & \tcode{<iterator>} \\
 \ref{iterator.primitives}   & Iterator primitives       &                    \\
 \ref{predef.iterators}      & Iterator adaptors         &                    \\
@@ -500,7 +500,7 @@
 \term{contiguous iterators},
 as shown in \tref{iterators.relations}.
 
-\begin{floattable}{Relations among iterator categories}{tab:iterators.relations}
+\begin{floattable}{Relations among iterator categories}{iterators.relations}
 {lllll}
 \topline
 \textbf{Contiguous}                  &
@@ -1746,13 +1746,13 @@
 \oldconcept{Destructible} requirements\iref{utility.arg.requirements} and lvalues
 of type \tcode{X} are swappable\iref{swappable.requirements}, and
 
-\item the expressions in \tref{iterator.requirements} are valid and have
+\item the expressions in \tref{iterator} are valid and have
 the indicated semantics.
 \end{itemize}
 
 \begin{libreqtab4b}
 {\oldconcept{Iterator} requirements}
-{tab:iterator.requirements}
+{iterator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
                     &                       &   \chdr{semantics}    &   \rhdr{pre-/post-condition}   \\ \capsep
@@ -1784,12 +1784,12 @@
 \tcode{T}
 if
 \tcode{X} satisfies the \oldconcept{Iterator}\iref{iterator.iterators} and
-\oldconcept{EqualityComparable} (\tref{equalitycomparable}) requirements and
-the expressions in \tref{iterator.input.requirements} are valid and have
+\oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements and
+the expressions in \tref{inputiterator} are valid and have
 the indicated semantics.
 
 \pnum
-In \tref{iterator.input.requirements}, the term
+In \tref{inputiterator}, the term
 \term{the domain of \tcode{==}}
 is used in the ordinary mathematical sense to denote
 the set of values over which
@@ -1819,7 +1819,7 @@
 
 \begin{libreqtab4b}
 {\oldconcept{InputIterator} requirements (in addition to \oldconcept{Iterator})}
-{tab:iterator.input.requirements}
+{inputiterator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
                     &                       &   \chdr{semantics}    &   \rhdr{pre-/post-condition}   \\ \capsep
@@ -1876,7 +1876,7 @@
 They should be
 \term{single pass}
 algorithms.
-Value type \tcode{T} is not required to be a \oldconcept{CopyAssignable} type (\tref{copyassignable}).
+Value type \tcode{T} is not required to be a \oldconcept{CopyAssignable} type (\tref{cpp17.copyassignable}).
 These algorithms can be used with istreams as the source of the input data through the
 \tcode{istream_iterator}
 class template.
@@ -1889,12 +1889,12 @@
 \tcode{X}
 satisfies the requirements of an output iterator
 if \tcode{X} satisfies the \oldconcept{Iterator} requirements\iref{iterator.iterators}
-and the expressions in \tref{iterator.output.requirements}
+and the expressions in \tref{outputiterator}
 are valid and have the indicated semantics.
 
 \begin{libreqtab4b}
 {\oldconcept{OutputIterator} requirements (in addition to \oldconcept{Iterator})}
-{tab:iterator.output.requirements}
+{outputiterator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
                     &                       &   \chdr{semantics}    &   \rhdr{pre-/post-condition}   \\ \capsep
@@ -1958,7 +1958,7 @@
 \item if \tcode{X} is a mutable iterator, \tcode{reference} is a reference to \tcode{T};
 if \tcode{X} is a constant iterator, \tcode{reference} is a reference to \tcode{const T},
 
-\item the expressions in \tref{iterator.forward.requirements}
+\item the expressions in \tref{forwarditerator}
 are valid and have the indicated semantics, and
 
 \item objects of type \tcode{X} offer the multi-pass guarantee, described below.
@@ -1996,7 +1996,7 @@
 
 \begin{libreqtab4b}
 {\oldconcept{ForwardIterator} requirements (in addition to \oldconcept{InputIterator})}
-{tab:iterator.forward.requirements}
+{forwarditerator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
                     &                       &   \chdr{semantics}    &   \rhdr{pre-/post-condition}   \\ \capsep
@@ -2033,11 +2033,11 @@
 \tcode{X}
 satisfies the requirements of a bidirectional iterator if,
 in addition to satisfying the \oldconcept{ForwardIterator} requirements,
-the following expressions are valid as shown in \tref{iterator.bidirectional.requirements}.
+the following expressions are valid as shown in \tref{bidirectionaliterator}.
 
 \begin{libreqtab4b}
 {\oldconcept{BidirectionalIterator} requirements (in addition to \oldconcept{ForwardIterator})}
-{tab:iterator.bidirectional.requirements}
+{bidirectionaliterator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
                     &                       &   \chdr{semantics}    &   \rhdr{pre-/post-condition}   \\ \capsep
@@ -2078,11 +2078,11 @@
 \tcode{X}
 satisfies the requirements of a random access iterator if,
 in addition to satisfying the \oldconcept{BidirectionalIterator} requirements,
-the following expressions are valid as shown in \tref{iterator.random.access.requirements}.
+the following expressions are valid as shown in \tref{randomaccessiterator}.
 
 \begin{libreqtab4b}
 {\oldconcept{RandomAccessIterator} requirements (in addition to \oldconcept{BidirectionalIterator})}
-{tab:iterator.random.access.requirements}
+{randomaccessiterator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Operational}  &   \rhdr{Assertion/note}       \\
                     &                       &   \chdr{semantics}    &   \rhdr{pre-/post-condition}   \\ \capsep
diff --git a/source/lex.tex b/source/lex.tex
index efc4e4e1f5..6d94beb844 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -395,9 +395,9 @@
 \tcode{[} and \tcode{<:} will be different, maintaining the source
 spelling, but the tokens can otherwise be freely interchanged. }
 The set of alternative tokens is defined in
-\tref{alternative.tokens}.
+\tref{lex.digraph}.
 
-\begin{tokentable}{Alternative tokens}{tab:alternative.tokens}{Alternative}{Primary}
+\begin{tokentable}{Alternative tokens}{lex.digraph}{Alternative}{Primary}
 \tcode{<\%}             &   \tcode{\{}         &
 \tcode{and}             &   \tcode{\&\&}       &
 \tcode{and_eq}          &   \tcode{\&=}        \\ \rowsep
@@ -583,10 +583,10 @@
 An identifier is an arbitrarily long sequence of letters and digits.
 Each \grammarterm{universal-character-name} in an identifier shall designate a
 character whose encoding in ISO/IEC 10646 falls into one of the ranges
-specified in \tref{charname.allowed}.
+specified in \tref{lex.name.allowed}.
 The initial element shall not be a \grammarterm{universal-character-name}
 designating a character whose encoding falls into one of the ranges
-specified in \tref{charname.disallowed}.
+specified in \tref{lex.name.disallowed}.
 Upper- and lower-case letters are
 different. All characters are significant.\footnote{On systems in which linkers cannot accept extended
 characters, an encoding of the \grammarterm{universal-character-name} may be used in
@@ -598,7 +598,7 @@
 identifiers. In \Cpp{}, upper- and lower-case letters are considered
 different for all identifiers, including external identifiers. }
 
-\begin{floattable}{Ranges of characters allowed}{tab:charname.allowed}
+\begin{floattable}{Ranges of characters allowed}{lex.name.allowed}
 {lllll}
 \topline
 \tcode{00A8} &
@@ -648,7 +648,7 @@
 \\
 \end{floattable}
 
-\begin{floattable}{Ranges of characters disallowed initially (combining characters)}{tab:charname.disallowed}
+\begin{floattable}{Ranges of characters disallowed initially (combining characters)}{lex.name.disallowed}
 {llll}
 \topline
 \tcode{0300-036F} &
@@ -665,14 +665,14 @@
 \indextext{\idxcode{final}}%
 \indextext{\idxcode{module}}%
 \indextext{\idxcode{override}}%
-The identifiers in \tref{identifiers.special} have a special meaning when
+The identifiers in \tref{lex.name.special} have a special meaning when
 appearing in a certain context. When referred to in the grammar, these identifiers
 are used explicitly rather than using the \grammarterm{identifier} grammar production.
 Unless otherwise specified, any ambiguity as to whether a given
 \grammarterm{identifier} has a special meaning is resolved to interpret the
 token as a regular \grammarterm{identifier}.
 
-\begin{multicolfloattable}{Identifiers with special meaning}{tab:identifiers.special}
+\begin{multicolfloattable}{Identifiers with special meaning}{lex.name.special}
 {lll}
 \keyword{audit}           \\
 \keyword{axiom}           \\
@@ -713,11 +713,11 @@
 \enlargethispage{\baselineskip}%
 \pnum
 \indextext{keyword|(}%
-The identifiers shown in \tref{keywords} are reserved for use
+The identifiers shown in \tref{lex.key} are reserved for use
 as keywords (that is, they are unconditionally treated as keywords in
 phase 7) except in an \grammarterm{attribute-token}\iref{dcl.attr.grammar}:
 
-\begin{multicolfloattable}{Keywords}{tab:keywords}
+\begin{multicolfloattable}{Keywords}{lex.key}
 {lllll}
 \keyword{alignas} \\
 \keyword{alignof} \\
@@ -810,12 +810,12 @@
 
 \pnum
 Furthermore, the alternative representations shown in
-\tref{alternative.representations} for certain operators and
+\tref{lex.key.digraph} for certain operators and
 punctuators\iref{lex.digraph} are reserved and shall not be used
 otherwise:
 
 
-\begin{floattable}{Alternative representations}{tab:alternative.representations}
+\begin{floattable}{Alternative representations}{lex.key.digraph}
 {llllll}
 \topline
 \keyword{and}     &   \keyword{and_eq}  &   \keyword{bitand}  &   \keyword{bitor}   &   \keyword{compl}   &   \keyword{not} \\
@@ -1006,11 +1006,11 @@
 \indextext{suffix!\idxcode{l}}%
 \indextext{suffix!\idxcode{u}}%
 The type of an integer literal is the first of the corresponding list
-in \tref{lex.type.integer.literal} in which its value can be
+in \tref{lex.icon.type} in which its value can be
 represented.
 
 \enlargethispage{\baselineskip}%
-\begin{LongTable}{Types of integer literals}{tab:lex.type.integer.literal}{l|l|l}
+\begin{LongTable}{Types of integer literals}{lex.icon.type}{l|l|l}
 \\ \topline
 \lhdr{Suffix} & \chdr{Decimal literal}  & \rhdr{Binary, octal, or hexadecimal literal}   \\  \capsep
 \endfirsthead
@@ -1255,7 +1255,7 @@
 \indextext{\idxcode{\textbackslash}|see{backslash character}}%
 \indextext{escape character|see{backslash character}}%
 \tcode{\textbackslash}, can be represented according to
-\tref{escape.sequences}.
+\tref{lex.ccon.esc}.
 \indextext{escape sequence!undefined}%
 The double quote \tcode{"}  and the question mark \tcode{?}, can be
 represented as themselves or by the escape sequences
@@ -1264,11 +1264,11 @@
 shall be represented by the escape sequences \tcode{\textbackslash'} and
 \tcode{\textbackslash\textbackslash} respectively. Escape sequences in
 which the character following the backslash is not listed in
-\tref{escape.sequences} are conditionally-supported, with \impldef{semantics of
+\tref{lex.ccon.esc} are conditionally-supported, with \impldef{semantics of
 non-standard escape sequences} semantics. An escape sequence specifies a single
 character.
 
-\begin{floattable}{Escape sequences}{tab:escape.sequences}
+\begin{floattable}{Escape sequences}{lex.ccon.esc}
 {llm}
 \topline
 new-line        &   NL(LF)          &   \tcode{\textbackslash n}                \\
@@ -1665,7 +1665,7 @@
 \end{note}
 \tref{lex.string.concat} has some examples of valid concatenations.
 
-\begin{floattable}{String literal concatenations}{tab:lex.string.concat}
+\begin{floattable}{String literal concatenations}{lex.string.concat}
 {lll|lll|lll}
 \topline
 \multicolumn{2}{|c}{Source} &
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index ed8c1c6361..2f051ed31b 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -22,7 +22,7 @@
 \ref{\firstlibchapter}--\ref{\lastlibchapter}, as shown in
 \tref{library.categories}.
 
-\begin{floattable}{Library categories}{tab:library.categories}
+\begin{floattable}{Library categories}{library.categories}
 {ll}
 \topline
 \hdstyle{Clause}        & \hdstyle{Category}          \\ \capsep
@@ -508,7 +508,7 @@
 requirements. Names in \textit{italic} type that begin with the prefix
 \oldconcept{} refer to sets of well-defined expression requirements typically
 presented in tabular form, possibly with additional prose semantic requirements.
-For example, \oldconcept{Destructible}~(\tref{destructible}) is such a named
+For example, \oldconcept{Destructible}~(\tref{cpp17.destructible}) is such a named
 requirement. Names in \tcode{constant width} type refer to library concepts
 which are presented as a concept definition\iref{temp}, possibly with additional
 prose semantic requirements. For example,
@@ -1063,7 +1063,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{EqualityComparable} (\tref{equalitycomparable}).
+Type \tcode{T} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}).
 
 \pnum
 \returns
@@ -1078,7 +1078,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -1093,7 +1093,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -1108,7 +1108,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{lessthancomparable}).
+Type \tcode{T} is \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \returns
@@ -1212,9 +1212,9 @@
 \pnum
 The \Cpp{} standard library provides the
 \defnx{\Cpp{} library headers}{header!C++ library},
-shown in \tref{cpp.library.headers}.
+shown in \tref{headers.cpp}.
 
-\begin{multicolfloattable}{\Cpp{} library headers}{tab:cpp.library.headers}
+\begin{multicolfloattable}{\Cpp{} library headers}{headers.cpp}
 {llll}
 \tcode{<algorithm>} \\
 \tcode{<any>} \\
@@ -1294,14 +1294,14 @@
 \pnum
 The facilities of the C standard library are provided in the
 \indextext{library!C standard}%
-additional headers shown in \tref{cpp.c.headers}.%
+additional headers shown in \tref{headers.cpp.c}.%
 \footnote{It is intentional that there is no \Cpp{} header
 for any of these C headers:
 \tcode{<stdatomic.h>}\indextext{\idxhdr{stdatomic.h}!absence thereof},
 \tcode{<stdnoreturn.h>}\indextext{\idxhdr{stdnoreturn.h}!absence thereof},
 \tcode{<threads.h>}\indextext{\idxhdr{threads.h}!absence thereof}.}
 
-\begin{multicolfloattable}{\Cpp{} headers for C library facilities}{tab:cpp.c.headers}
+\begin{multicolfloattable}{\Cpp{} headers for C library facilities}{headers.cpp.c}
 {lllllll}
 \tcode{<cassert>} \\
 \tcode{<cctype>} \\
@@ -1395,7 +1395,7 @@
 that may be declared in some header.
 These names are also subject to the restrictions of~\ref{macro.names}.
 
-\begin{multicolfloattable}{C standard Annex K names}{tab:c.annex.k.names}
+\begin{multicolfloattable}{C standard Annex K names}{c.annex.k.names}
 {llll}
 \tcode{abort_handler_s} \\
 \tcode{asctime_s} \\
@@ -1491,9 +1491,9 @@
 \pnum
 A freestanding implementation\indextext{implementation!freestanding} has an
 \impldef{headers for freestanding implementation} set of headers. This set shall
-include at least the headers shown in \tref{cpp.headers.freestanding}.
+include at least the headers shown in \tref{headers.cpp.fs}.
 
-\begin{libsumtab}{\Cpp{} headers for freestanding implementations}{tab:cpp.headers.freestanding}
+\begin{libsumtab}{\Cpp{} headers for freestanding implementations}{headers.cpp.fs}
 \ref{support.types}      & Types                     & \tcode{<cstddef>}          \\ \rowsep
 \ref{support.limits}     & Implementation properties &
   \tcode{<cfloat>}, \tcode{<climits>}, \tcode{<limits>}, \tcode{<version>} \\ \rowsep
@@ -1630,7 +1630,7 @@
 \pnum
 The template definitions in the \Cpp{} standard library
 refer to various named requirements whose details are set out in
-Tables~\ref{tab:equalitycomparable}--\ref{tab:destructible}.
+Tables~\ref{tab:cpp17.equalitycomparable}--\ref{tab:cpp17.destructible}.
 In these tables, \tcode{T} is an object or reference type to be
 supplied by a \Cpp{} program instantiating a template;
 \tcode{a},
@@ -1649,7 +1649,7 @@
 signatures is called using the default argument\iref{dcl.fct.default}.
 
 \indextext{requirements!\idxoldconcept{EqualityComparable}}%
-\begin{concepttable}{\oldconcept{EqualityComparable} requirements}{equalitycomparable}
+\begin{concepttable}{\oldconcept{EqualityComparable} requirements}{cpp17.equalitycomparable}
 {x{1in}x{1in}p{3in}}
 \topline
 \hdstyle{Expression}  &   \hdstyle{Return type} &   \rhdr{Requirement} \\ \capsep
@@ -1668,7 +1668,7 @@
 \end{concepttable}
 
 \indextext{requirements!\idxoldconcept{LessThanComparable}}%
-\begin{concepttable}{\oldconcept{LessThanComparable} requirements}{lessthancomparable}
+\begin{concepttable}{\oldconcept{LessThanComparable} requirements}{cpp17.lessthancomparable}
 {x{1in}x{1in}p{3in}}
 \topline
 \hdstyle{Expression}  &   \hdstyle{Return type} &   \hdstyle{Requirement} \\ \capsep
@@ -1679,7 +1679,7 @@
 
 \enlargethispage{-3\baselineskip}
 \indextext{requirements!\idxoldconcept{DefaultConstructible}}%
-\begin{concepttable}{\oldconcept{DefaultConstructible} requirements}{defaultconstructible}
+\begin{concepttable}{\oldconcept{DefaultConstructible} requirements}{cpp17.defaultconstructible}
 {x{2.15in}p{3in}}
 \topline
 \hdstyle{Expression}        &     \hdstyle{Post-condition}  \\ \capsep
@@ -1690,7 +1690,7 @@
 \end{concepttable}
 
 \indextext{requirements!\idxoldconcept{MoveConstructible}}%
-\begin{concepttable}{\oldconcept{MoveConstructible} requirements}{moveconstructible}
+\begin{concepttable}{\oldconcept{MoveConstructible} requirements}{cpp17.moveconstructible}
 {p{1in}p{4.15in}}
 \topline
 \hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
@@ -1705,7 +1705,7 @@
 \end{concepttable}
 
 \indextext{requirements!\idxoldconcept{CopyConstructible}}%
-\begin{concepttable}{\oldconcept{CopyConstructible} requirements (in addition to \oldconcept{MoveConstructible})}{copyconstructible}
+\begin{concepttable}{\oldconcept{CopyConstructible} requirements (in addition to \oldconcept{MoveConstructible})}{cpp17.copyconstructible}
 {p{1in}p{4.15in}}
 \topline
 \hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
@@ -1715,7 +1715,7 @@
 \end{concepttable}
 
 \indextext{requirements!\idxoldconcept{MoveAssignable}}%
-\begin{concepttable}{\oldconcept{MoveAssignable} requirements}{moveassignable}
+\begin{concepttable}{\oldconcept{MoveAssignable} requirements}{cpp17.moveassignable}
 {p{1in}p{1in}p{1in}p{1.9in}}
 \topline
 \hdstyle{Expression} & \hdstyle{Return type} & \hdstyle{Return value} & \hdstyle{Post-condition} \\ \capsep
@@ -1731,7 +1731,7 @@
 \end{concepttable}
 
 \indextext{requirements!\idxoldconcept{CopyAssignable}}%
-\begin{concepttable}{\oldconcept{CopyAssignable} requirements (in addition to \oldconcept{MoveAssignable})}{copyassignable}
+\begin{concepttable}{\oldconcept{CopyAssignable} requirements (in addition to \oldconcept{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
@@ -1739,7 +1739,7 @@
 \end{concepttable}
 
 \indextext{requirements!\idxoldconcept{Destructible}}
-\begin{concepttable}{\oldconcept{Destructible} requirements}{destructible}
+\begin{concepttable}{\oldconcept{Destructible} requirements}{cpp17.destructible}
 {p{1in}p{4.15in}}
 \topline
 \hdstyle{Expression}      &   \hdstyle{Post-condition}  \\ \capsep
@@ -1858,7 +1858,7 @@
 
 \item lvalues of type \tcode{P} are swappable\iref{swappable.requirements},
 
-\item the expressions shown in \tref{nullablepointer} are
+\item the expressions shown in \tref{cpp17.nullablepointer} are
 valid and have the indicated semantics, and
 
 \item \tcode{P} satisfies all the other requirements of this subclause.
@@ -1880,13 +1880,13 @@
 via an exception.
 
 \pnum
-In \tref{nullablepointer}, \tcode{u} denotes an identifier, \tcode{t}
+In \tref{cpp17.nullablepointer}, \tcode{u} denotes an identifier, \tcode{t}
 denotes a non-\tcode{const} lvalue of type \tcode{P}, \tcode{a} and \tcode{b}
 denote values of type (possibly \tcode{const}) \tcode{P}, and \tcode{np} denotes
 a value of type (possibly \tcode{const}) \tcode{std::nullptr_t}.
 
 \indextext{requirements!\idxoldconcept{NullablePointer}}%
-\begin{concepttable}{\oldconcept{NullablePointer} requirements}{nullablepointer}
+\begin{concepttable}{\oldconcept{NullablePointer} requirements}{cpp17.nullablepointer}
 {lll}
 \topline
 Expression  &   Return type   &   Operational semantics \\ \capsep
@@ -1931,19 +1931,19 @@
 
 \begin{itemize}
 \item it is a function object type\iref{function.objects},
-\item it satisfies the \oldconcept{CopyConstructible} (\tref{copyconstructible}) and
-  \oldconcept{Destructible} (\tref{destructible}) requirements, and
-\item the expressions shown in \tref{hash}
+\item it satisfies the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
+  \oldconcept{Destructible} (\tref{cpp17.destructible}) requirements, and
+\item the expressions shown in \tref{cpp17.hash}
 are valid and have the indicated semantics.
 \end{itemize}
 
 \pnum
 Given \tcode{Key} is an argument type for function objects of type \tcode{H}, in
-\tref{hash} \tcode{h} is a value of type (possibly \tcode{const}) \tcode{H},
+\tref{cpp17.hash} \tcode{h} is a value of type (possibly \tcode{const}) \tcode{H},
 \tcode{u} is an lvalue of type \tcode{Key}, and \tcode{k} is a value of a type convertible to
 (possibly \tcode{const}) \tcode{Key}.
 
-\begin{concepttable}{\oldconcept{Hash} requirements}{hash}
+\begin{concepttable}{\oldconcept{Hash} requirements}{cpp17.hash}
 {llp{.55\hsize}}
 \topline
 Expression        &     Return type     &       Requirement \\ \capsep
@@ -1979,24 +1979,24 @@
 \pnum
 The class template \tcode{allocator_traits}\iref{allocator.traits} supplies
 a uniform interface to all allocator types.
-\tref{desc.var.def} describes the types manipulated
-through allocators. \tref{utilities.allocator.requirements}
+\tref{allocator.req.var} describes the types manipulated
+through allocators. \tref{cpp17.allocator}
 describes the requirements on allocator types
 and thus on types used to instantiate \tcode{allocator_traits}. A requirement
 is optional if the last column of
-\tref{utilities.allocator.requirements} specifies a default for a
+\tref{cpp17.allocator} specifies a default for a
 given expression. Within the standard library \tcode{allocator_traits}
 template, an optional requirement that is not supplied by an allocator is
 replaced by the specified default expression. A user specialization of
 \tcode{allocator_traits} may provide different defaults and may provide
 defaults for different requirements than the primary template. Within
-Tables~\ref{tab:desc.var.def} and~\ref{tab:utilities.allocator.requirements},
+Tables~\ref{tab:allocator.req.var} and~\ref{tab:cpp17.allocator},
 the use of \tcode{move} and \tcode{forward} always refers to \tcode{std::move}
 and \tcode{std::forward}, respectively.
 
 \begin{libreqtab2}
 {Descriptive variable definitions}
-{tab:desc.var.def}
+{allocator.req.var}
 \\ \topline
 \lhdr{Variable} &   \rhdr{Definition}   \\  \capsep
 \endfirsthead
@@ -2033,7 +2033,7 @@
 
 \begin{libreqtab4d}
 {\oldconcept{Allocator} requirements}
-{tab:utilities.allocator.requirements}
+{cpp17.allocator}
 \\ \topline
 \lhdr{Expression}   &   \chdr{Return type}  &   \chdr{Assertion/note} & \rhdr{Default}       \\
                     &                       &   \chdr{pre-/post-condition}  &   \\ \capsep
@@ -2245,11 +2245,11 @@
 Note B:
 If \tcode{X::propagate_on_container_copy_assignment::value} is \tcode{true},
 \tcode{X} shall satisfy the
-\oldconcept{\-Copy\-Assign\-able} requirements (\tref{copyassignable})
+\oldconcept{\-Copy\-Assign\-able} requirements (\tref{cpp17.copyassignable})
 and the copy operation shall not throw exceptions.
 If \tcode{X::propagate_on_container_move_assignment::value} is \tcode{true},
 \tcode{X} shall satisfy the
-\oldconcept{\-Move\-Assign\-able} requirements (\tref{moveassignable})
+\oldconcept{\-Move\-Assign\-able} requirements (\tref{cpp17.moveassignable})
 and the move operation shall not throw exceptions.
 If \tcode{X::propagate_on_container_swap::value} is \tcode{true},
 lvalues of type \tcode{X} shall be swappable\iref{swappable.requirements}
@@ -2257,10 +2257,10 @@
 
 \pnum
 An allocator type \tcode{X} shall meet the
-\oldconcept{CopyConstructible} requirements (\tref{copyconstructible}).
+\oldconcept{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
 The \tcode{X::pointer}, \tcode{X::const_pointer}, \tcode{X::void_pointer}, and
 \tcode{X::const_void_pointer} types shall meet the
-\oldconcept{Nullable\-Pointer} requirements (\tref{nullablepointer}).
+\oldconcept{Nullable\-Pointer} requirements (\tref{cpp17.nullablepointer}).
 No constructor,
 comparison function, copy operation, move operation, or swap operation on
 these pointer types shall exit via an exception. \tcode{X::pointer} and \tcode{X::const_pointer} shall also
@@ -2325,7 +2325,7 @@
 \pnum
 \begin{example} The following is an allocator class template supporting the minimal
 interface that satisfies the requirements of
-\tref{utilities.allocator.requirements}:
+\tref{cpp17.allocator}:
 
 \begin{codeblock}
 template<class Tp>
@@ -2629,7 +2629,7 @@
 A translation unit shall not \tcode{\#define} or \tcode{\#undef}
 names lexically identical
 to keywords,
-to the identifiers listed in \tref{identifiers.special},
+to the identifiers listed in \tref{lex.name.special},
 to the \grammarterm{attribute-token}{s} described in~\ref{dcl.attr}, or
 to the identifiers \tcode{expects} or \tcode{ensures},
 except that the names \tcode{likely} and \tcode{unlikely} may be
diff --git a/source/locales.tex b/source/locales.tex
index dc1777d9c0..cda404916f 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -14,9 +14,9 @@
 \pnum
 The following subclauses describe components for
 locales themselves, the standard facets, and facilities
-from the ISO C library, as summarized in \tref{localization.lib.summary}.
+from the ISO C library, as summarized in \tref{localization.summary}.
 
-\begin{libsumtab}{Localization library summary}{tab:localization.lib.summary}
+\begin{libsumtab}{Localization library summary}{localization.summary}
 \ref{locales} & Locales                   &   \tcode{<locale>}    \\
 \ref{locale.categories} & Standard \tcode{locale} categories &   \\ \rowsep
 \ref{c.locales} & C library locales       &   \tcode{<clocale>}   \\
@@ -340,9 +340,9 @@
 value identifies a set of locale categories.
 Each locale category,
 in turn, identifies a set of locale facets, including at least those
-shown in \tref{localization.category.facets}.
+shown in \tref{locale.category.facets}.
 
-\begin{floattable}{Locale category facets}{tab:localization.category.facets}
+\begin{floattable}{Locale category facets}{locale.category.facets}
 {ml}
 \topline
 \lhdr{Category} &   \rhdr{Includes facets}                                      \\ \capsep
@@ -369,7 +369,7 @@
 either constructed, or returned by
 \tcode{locale::classic()},
 and any facet \tcode{Facet}
-shown in \tref{localization.category.facets},
+shown in \tref{locale.category.facets},
 \tcode{has_facet<Facet>(loc)}
 is \tcode{true}.
 Each
@@ -381,9 +381,9 @@
 \pnum
 An implementation is required to provide those specializations for
 facet templates identified as members of a category, and for those
-shown in \tref{localization.required.specializations}.
+shown in \tref{locale.spec}.
 
-\begin{floattable}{Required specializations}{tab:localization.required.specializations}
+\begin{floattable}{Required specializations}{locale.spec}
 {ml}
 \topline
 \lhdr{Category} &   \rhdr{Includes facets}                                          \\ \capsep
@@ -1174,7 +1174,7 @@
 for character classing during input parsing.
 
 \pnum
-The specializations required in \tref{localization.category.facets}\iref{locale.category}, namely
+The specializations required in \tref{locale.category.facets}\iref{locale.category}, namely
 \tcode{ctype<char>}
 and
 \tcode{ctype<wchar_t>},
@@ -1895,7 +1895,7 @@
 argument selects the pair of character encodings being mapped between.
 
 \pnum
-The specializations required in \tref{localization.category.facets}\iref{locale.category}
+The specializations required in \tref{locale.category.facets}\iref{locale.category}
 convert the implementation-defined native character set.
 \tcode{codecvt<char, char, mbstate_t>}
 implements a degenerate conversion;
@@ -2111,9 +2111,9 @@
 
 \pnum
 \returns
-An enumeration value, as summarized in \tref{localization.convert.result.values.out.in}.
+An enumeration value, as summarized in \tref{locale.codecvt.inout}.
 
-\begin{floattable}{\tcode{do_in/do_out} result values}{tab:localization.convert.result.values.out.in}
+\begin{floattable}{\tcode{do_in/do_out} result values}{locale.codecvt.inout}
 {lp{3in}}
 \topline
 \lhdr{Value}    &   \rhdr{Meaning}                                  \\ \capsep
@@ -2163,9 +2163,9 @@
 
 \pnum
 \returns
-An enumeration value, as summarized in \tref{localization.convert.result.values.unshift}.
+An enumeration value, as summarized in \tref{locale.codecvt.unshift}.
 
-\begin{floattable}{\tcode{do_unshift} result values}{tab:localization.convert.result.values.unshift}
+\begin{floattable}{\tcode{do_unshift} result values}{locale.codecvt.unshift}
 {lp{.50\hsize}}
 \topline
 \lhdr{Value}                &   \rhdr{Meaning}                                          \\ \capsep
@@ -2318,8 +2318,8 @@
 and
 \tcode{num_get}
 in the subclauses of~\ref{category.numeric} only apply to the
-specializations required in Tables~\ref{tab:localization.category.facets}
-and~\ref{tab:localization.required.specializations}\iref{locale.category}, namely
+specializations required in Tables~\ref{tab:locale.category.facets}
+and~\ref{tab:locale.spec}\iref{locale.category}, namely
 \tcode{num_get<char>},
 \tcode{num_get<wchar_t>},
 \tcode{num_get<C, InputIterator>},
@@ -2522,11 +2522,11 @@
 
 For conversion to an integral type, the
 function determines the integral conversion specifier as indicated in
-\tref{localization.integer.conversions.in}.
+\tref{facet.num.get.int}.
 The table is ordered.
 That is, the first line whose condition is true applies.
 
-\begin{floattable}{Integer conversions}{tab:localization.integer.conversions.in}
+\begin{floattable}{Integer conversions}{facet.num.get.int}
 {lc}
 \topline
 \lhdr{State}                    &   \tcode{stdio} equivalent   \\ \capsep
@@ -2546,9 +2546,9 @@
 \tcode{\%p}.
 
 A length modifier is added to the conversion specification, if needed,
-as indicated in \tref{localization.length.modifier.in}.
+as indicated in \tref{facet.num.get.length}.
 
-\begin{floattable}{Length modifier}{tab:localization.length.modifier.in}
+\begin{floattable}{Length modifier}{facet.num.get.length}
 {lc}
 \topline
 \lhdr{Type}                 &   Length modifier \\ \capsep
@@ -2908,9 +2908,9 @@
 
 For conversion from an integral type other than a character type, the
 function determines the integral conversion specifier as indicated in
-\tref{localization.integer.conversions.out}.
+\tref{facet.num.put.int}.
 
-\begin{floattable}{Integer conversions}{tab:localization.integer.conversions.out}
+\begin{floattable}{Integer conversions}{facet.num.put.int}
 {lc}
 \topline
 \lhdr{State}                        &   \tcode{stdio} equivalent       \\ \capsep
@@ -2922,9 +2922,9 @@
 \end{floattable}
 
 For conversion from a floating-point type, the function determines
-the floating-point conversion specifier as indicated in \tref{localization.fp.conversions.out}.
+the floating-point conversion specifier as indicated in \tref{facet.num.put.fp}.
 
-\begin{floattable}{Floating-point conversions}{tab:localization.fp.conversions.out}
+\begin{floattable}{Floating-point conversions}{facet.num.put.fp}
 {lc}
 \topline
 \lhdr{State}            &   \tcode{stdio} equivalent                       \\ \capsep
@@ -2939,9 +2939,9 @@
 
 For conversions from an integral or floating-point
 type a length modifier is added to the
-conversion specifier as indicated in  \tref{localization.length.modifier.out}.
+conversion specifier as indicated in  \tref{facet.num.put.length}.
 
-\begin{floattable}{Length modifier}{tab:localization.length.modifier.out}
+\begin{floattable}{Length modifier}{facet.num.put.length}
 {lc}
 \topline
 \lhdr{Type}                 &   Length modifier \\ \capsep
@@ -2954,9 +2954,9 @@
 \end{floattable}
 
 The conversion specifier has the following optional additional qualifiers
-prepended as indicated in \tref{localization.numeric.conversions}.
+prepended as indicated in \tref{facet.num.put.conv}.
 
-\begin{floattable}{Numeric conversions}{tab:localization.numeric.conversions}
+\begin{floattable}{Numeric conversions}{facet.num.put.conv}
 {llc}
 \topline
 \lhdr{Type(s)}                  &   \chdr{State}       &   \tcode{stdio} equivalent   \\ \capsep
@@ -3018,9 +3018,9 @@
 \tcode{0}
 which is
 \textit{not}
-a padding character.} is determined according to \tref{localization.fill.padding}.
+a padding character.} is determined according to \tref{facet.num.put.fill}.
 
-\begin{floattable}{Fill padding}{tab:localization.fill.padding}
+\begin{floattable}{Fill padding}{facet.num.put.fill}
 {p{3in}l}
 \topline
 \lhdr{State}                            &   \rhdr{Location}                 \\ \capsep
@@ -3126,7 +3126,7 @@
 \pnum
 \tcode{numpunct<>}
 specifies numeric punctuation.
-The specializations required in \tref{localization.category.facets}\iref{locale.category}, namely
+The specializations required in \tref{locale.category.facets}\iref{locale.category}, namely
 \tcode{numpunct<\brk{}wchar_t>}
 and
 \tcode{numpunct<char>},
@@ -3368,7 +3368,7 @@
 \tcode{operator()},
 uses the collate facet to allow a locale to act directly as the predicate
 argument for standard algorithms\iref{algorithms} and containers operating on strings.
-The specializations required in \tref{localization.category.facets}\iref{locale.category}, namely
+The specializations required in \tref{locale.category.facets}\iref{locale.category}, namely
 \tcode{collate<char>}
 and
 \tcode{collate<wchar_t>},
@@ -3431,7 +3431,7 @@
 if the first string is greater than the second,
 \tcode{-1}
 if less, zero otherwise.
-The specializations required in \tref{localization.category.facets}\iref{locale.category}, namely
+The specializations required in \tref{locale.category.facets}\iref{locale.category}, namely
 \tcode{collate<char>}
 and
 \tcode{collate<wchar_t>},
@@ -3509,8 +3509,8 @@
 and
 \tcode{time_get}
 in the subclauses of~\ref{category.time} only apply to the
-specializations required in Tables~\ref{tab:localization.category.facets}
-and~\ref{tab:localization.required.specializations}\iref{locale.category}.
+specializations required in Tables~\ref{tab:locale.category.facets}
+and~\ref{tab:locale.spec}\iref{locale.category}.
 Their members use their
 \tcode{ios_base\&},
 \tcode{ios_base::iostate\&},
@@ -3811,9 +3811,9 @@
 to produce one of the following formats,
 or until it encounters an error. The format depends on the value returned
 by \tcode{date_order()} as shown in
-\tref{lib.locale.time.get.virtuals.dogetdate}.
+\tref{locale.time.get.dogetdate}.
 
-\begin{libtab2}{\tcode{do_get_date} effects}{tab:lib.locale.time.get.virtuals.dogetdate}
+\begin{libtab2}{\tcode{do_get_date} effects}{locale.time.get.dogetdate}
 {ll}{\tcode{date_order()}}{Format}
 \tcode{no_order}  & \tcode{"\%m\%d\%y"} \\
 \tcode{dmy}       & \tcode{"\%d\%m\%y"} \\
@@ -4118,8 +4118,8 @@
 and
 \tcode{money_get}
 in the subclauses of~\ref{category.monetary} only apply to the
-specializations required in Tables~\ref{tab:localization.category.facets}
-and~\ref{tab:localization.required.specializations}\iref{locale.category}.
+specializations required in Tables~\ref{tab:locale.category.facets}
+and~\ref{tab:locale.spec}\iref{locale.category}.
 Their members use their
 \tcode{ios_base\&},
 \tcode{ios_base::io\-state\&},
@@ -4825,7 +4825,7 @@
 \begin{itemdescr}
 \pnum
 \returns
-The specializations required in \tref{localization.required.specializations}\iref{locale.category}, namely
+The specializations required in \tref{locale.spec}\iref{locale.category}, namely
 \tcode{moneypunct<char>},
 \tcode{moneypunct<\brk{}wchar_t>},
 \tcode{moneypunct<char, true>},
@@ -5083,7 +5083,7 @@
 
 \begin{floattable}
 {Potential \tcode{setlocale} data races}
-{tab:setlocale.data.races}
+{setlocale.data.races}
 {lllll}
 \topline
 
diff --git a/source/macros.tex b/source/macros.tex
index 5ed34b8daa..0659030280 100644
--- a/source/macros.tex
+++ b/source/macros.tex
@@ -273,6 +273,8 @@
 
 %% Inline non-parenthesized table reference (override memoir's \tref)
 \renewcommand{\tref}[1]{\hyperref[tab:#1]{\tablerefname \nolinebreak[3] \ref*{tab:#1}}}
+%% Inline non-parenthesized figure reference (override memoir's \fref)
+\renewcommand{\fref}[1]{\hyperref[fig:#1]{\figurerefname \nolinebreak[3] \ref*{fig:#1}}}
 
 %% NTBS, etc.
 \newcommand{\NTS}[1]{\textsc{#1}}
@@ -545,7 +547,7 @@
 \includegraphics[scale=.35]{#3}
 }
 {
-\caption{\cptn}\label{\lbl}%
+\caption{\cptn \quad [fig:\lbl]}\label{fig:\lbl}%
 \end{figure}}
 
 %%--------------------------------------------------
diff --git a/source/numerics.tex b/source/numerics.tex
index 6964ec5386..22560cdbaf 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -14,9 +14,9 @@
 \textit{n}-at-a-time)
 arrays, generalized numeric algorithms,
 and mathematical functions for floating-point types,
-as summarized in \tref{numerics.lib.summary}.
+as summarized in \tref{numerics.summary}.
 
-\begin{libsumtab}{Numerics library summary}{tab:numerics.lib.summary}
+\begin{libsumtab}{Numerics library summary}{numerics.summary}
 \ref{numeric.requirements}  & Requirements &           \\ \rowsep
 \ref{cfenv}           & Floating-point environment & \tcode{<cfenv>}  \\ \rowsep
 \ref{complex.numbers} & Complex numbers & \tcode{<complex>} \\ \rowsep
@@ -1809,7 +1809,7 @@
 satisfies the requirements
 of a seed sequence
 if the expressions shown
-in \tref{SeedSequence}
+in \tref{rand.req.seedseq}
 are valid and have the indicated semantics,
 and if \tcode{S} also satisfies all other requirements
 of this subclause \ref{rand.req.seedseq}.
@@ -1838,7 +1838,7 @@
 
 \begin{libreqtab4d}
   {Seed sequence requirements}
-  {tab:SeedSequence}
+  {rand.req.seedseq}
 \\ \topline
 \lhdr{Expression}
   & \chdr{Return type}
@@ -2036,7 +2036,7 @@
 also satisfies the requirements
 of a \term{random number engine}
 if the expressions shown
-in \tref{RandomEngine}
+in \tref{rand.req.eng}
 are valid and have the indicated semantics,
 and if \tcode{E} also satisfies all other requirements
 of this subclause \ref{rand.req.eng}.
@@ -2070,7 +2070,7 @@
 
 \begin{libreqtab4d}
   {Random number engine requirements}
-  {tab:RandomEngine}
+  {rand.req.eng}
 \\ \topline
 \lhdr{Expression}
   & \chdr{Return type}
@@ -2244,8 +2244,8 @@
 
 \pnum
 \tcode{E} shall satisfy the
-\oldconcept{CopyConstructible} (\tref{copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{copyassignable}) requirements.
+\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 These operations shall each be of complexity
 no worse than \bigoh{\text{size of state}}.
 
@@ -2419,7 +2419,7 @@
 satisfies the requirements
 of a \term{random number distribution}
 if the expressions shown
-in \tref{RandomDistribution}
+in \tref{rand.req.dist}
 are valid and have the indicated semantics,
 and if \tcode{D} and its associated types
 also satisfy all other requirements
@@ -2463,7 +2463,7 @@
 
 \begin{libreqtab4d}
   {Random number distribution requirements}
-  {tab:RandomDistribution}
+  {rand.req.dist}
 \\ \topline
 \lhdr{Expression}
   & \chdr{Return type}
@@ -2623,8 +2623,8 @@
 
 \pnum
 \tcode{D} shall satisfy the
-\oldconcept{CopyConstructible} (\tref{copyconstructible})
-and \oldconcept{CopyAssignable} (\tref{copyassignable}) requirements.
+\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible})
+and \oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}) requirements.
 
 \pnum
 The sequence of numbers
@@ -2655,10 +2655,10 @@
 
 \pnum
 \tcode{P} shall satisfy the
-\oldconcept{CopyConstructible} (\tref{copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{copyassignable}),
+\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
 and
-\oldconcept{Equality\-Comp\-arable} (\tref{equalitycomparable}) requirements.
+\oldconcept{Equality\-Comp\-arable} (\tref{cpp17.equalitycomparable}) requirements.
 
 \pnum
 For each of the constructors of \tcode{D}
diff --git a/source/overloading.tex b/source/overloading.tex
index 6df045151e..098ec2b670 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -982,12 +982,12 @@
 operator.
 Therefore, the operator notation is first transformed
 to the equivalent function-call notation as summarized in
-\tref{over.rel.op.func}
+\tref{over.match.oper}
 (where \tcode{@} denotes one of the operators covered in the specified subclause).
 However, the operands are sequenced in the order prescribed
 for the built-in operator\iref{expr.compound}.
 
-\begin{floattable}{Relationship between operator and function call notation}{tab:over.rel.op.func}
+\begin{floattable}{Relationship between operator and function call notation}{over.match.oper}
 {l|m|m|m}
 \topline
 \hdstyle{Subclause} &   \hdstyle{Expression} &   \hdstyle{As member function} &   \hdstyle{As non-member function} \\ \capsep
@@ -2140,7 +2140,7 @@
 \rSec4[over.ics.scs]{Standard conversion sequences}
 
 \pnum
-\tref{over.conversions}
+\tref{over.ics.scs}
 summarizes the conversions defined in \ref{conv} and
 partitions them into four disjoint categories: Lvalue Transformation,
 Qualification Adjustment, Promotion, and Conversion.
@@ -2172,7 +2172,7 @@
 
 \pnum
 \indextext{conversion rank}%
-Each conversion in \tref{over.conversions}
+Each conversion in \tref{over.ics.scs}
 also has an associated rank (Exact
 Match, Promotion, or Conversion).
 These are used
@@ -2185,7 +2185,7 @@
 the sequence has Promotion rank; otherwise, the sequence has Exact
 Match rank.
 
-\begin{floattable}{Conversions}{tab:over.conversions}{l|c|c|c}
+\begin{floattable}{Conversions}{over.ics.scs}{l|c|c|c}
 \topline
 \hdstyle{Conversion}            &   \hdstyle{Category}          &   \hdstyle{Rank}  &   \hdstyle{Subclause} \\ \capsep
 No conversions required         &   Identity                    &                   &                       \\ \cline{1-2}\cline{4-4}
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index 8a523e862b..1f2c35d974 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -294,7 +294,7 @@
 that the availability of an attribute can be detected by any non-zero result.
 \end{note}
 
-\begin{floattable}{\xname{has_cpp_attribute} values}{tab:cpp.cond.ha}
+\begin{floattable}{\xname{has_cpp_attribute} values}{cpp.cond.ha}
 {ll}
 \topline
 \lhdr{Attribute} & \rhdr{Value} \\ \rowsep
@@ -1663,7 +1663,7 @@
 \end{note}
 \end{description}
 
-\begin{LongTable}{Feature-test macros}{tab:cpp.predefined.ft}{ll}
+\begin{LongTable}{Feature-test macros}{cpp.predefined.ft}{ll}
 \\ \topline
 \lhdr{Macro name} & \rhdr{Value} \\ \capsep
 \endfirsthead
diff --git a/source/ranges.tex b/source/ranges.tex
index 08f1e6489e..e5ca3a5cab 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -13,7 +13,7 @@
 range primitives
 as summarized in \tref{range.summary}.
 
-\begin{libsumtab}{Ranges library summary}{tab:range.summary}
+\begin{libsumtab}{Ranges library summary}{range.summary}
   \ref{range.access}       & Range access      & \tcode{<ranges>} \\
   \ref{range.req}          & Requirements      & \\
   \ref{range.utility}      & Range utilities   & \\
diff --git a/source/regex.tex b/source/regex.tex
index 24f60e87f2..4398840ead 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -18,9 +18,9 @@
 result of a regular expression match, a series of algorithms that allow a character
 sequence to be operated upon by a regular expression,
 and two iterator types for
-enumerating regular expression matches, as summarized in \tref{re.lib.summary}.
+enumerating regular expression matches, as summarized in \tref{re.summary}.
 
-\begin{libsumtab}{Regular expressions library summary}{tab:re.lib.summary}
+\begin{libsumtab}{Regular expressions library summary}{re.summary}
 \ref{re.def}        &   Definitions                 &                       \\
 \ref{re.req}        &   Requirements                &                       \\ \rowsep
 \ref{re.const}      &   Constants                   & \tcode{<regex>}       \\
@@ -108,7 +108,7 @@
 \indextext{requirements!regular expression traits}%
 \indextext{regular expression!requirements}%
 \indextext{locale}%
-In \tref{re:RegexpTraits} \tcode{X} denotes a traits class
+In \tref{re.req} \tcode{X} denotes a traits class
 defining types and functions for the character container
 type \tcode{charT}; \tcode{u} is an object of
 type \tcode{X}; \tcode{v} is an object of type \tcode{const
@@ -125,7 +125,7 @@
 
 \begin{libreqtab3}
   {Regular expression traits class requirements}
-  {tab:re:RegexpTraits}
+  {re.req}
 \\ \topline
 \lhdr{Expression} & \chdr{Return type} & \rhdr{Assertion/note pre-/post-condition } \\ \capsep
 \endfirsthead
@@ -654,14 +654,14 @@
 \indexlibrary{\idxcode{syntax_option_type}!\idxcode{egrep}}%
 The type \tcode{syntax_option_type} is an \impldef{type of \tcode{syntax_option_type}} bitmask
 type\iref{bitmask.types}. Setting its elements has the effects listed in
-\tref{re:syntaxoption}.  A valid value of type
+\tref{re.synopt}.  A valid value of type
 \tcode{syntax_option_type} shall have at most one of the grammar elements
 \tcode{ECMAScript}, \tcode{basic}, \tcode{extended}, \tcode{awk}, \tcode{grep}, \tcode{egrep}, set.
 If no grammar element is set, the default grammar is \tcode{ECMAScript}.
 
 \begin{libefftab}
   {\tcode{syntax_option_type} effects}
-  {tab:re:syntaxoption}
+  {re.synopt}
 %
 \tcode{icase} &
 Specifies that matching of regular expressions against a character
@@ -794,13 +794,13 @@
 \tcode{format_default} constants are empty bitmasks.
 Matching a regular expression against a sequence of characters
 \range{first}{last} proceeds according to the rules of the grammar specified for the regular
-expression object, modified according to the effects listed in \tref{re:matchflag} for
+expression object, modified according to the effects listed in \tref{re.matchflag} for
 any bitmask elements set.
 
 \begin{longlibefftab}
   {\tcode{regex_constants::match_flag_type} effects when obtaining a match against a
      character container sequence \range{first}{last}.}
-  {tab:re:matchflag}
+  {re.matchflag}
 %
 \indexlibrary{\idxcode{match_not_bol}}%
 \tcode{match_not_bol} &
@@ -913,11 +913,11 @@
 The type \tcode{error_type} is an \impldef{type of
 \tcode{regex_constants::error_type}} enumerated type\iref{enumerated.types}.
 Values of type \tcode{error_type} represent the error
-conditions described in \tref{re:errortype}:
+conditions described in \tref{re.err}:
 
 \begin{longliberrtab}
   {\tcode{error_type} values in the C locale}
-  {tab:re:errortype}
+  {re.err}
 \tcode{error_collate}
 &
 The expression contained an invalid collating element name.  \\ \rowsep
@@ -1279,7 +1279,7 @@
 the last argument passed to \tcode{imbue}.
 \end{itemdescr}
 
-\begin{floattable}{Character class names and corresponding \tcode{ctype} masks}{tab:re.traits.classnames}{lll}
+\begin{floattable}{Character class names and corresponding \tcode{ctype} masks}{re.traits.classnames}{lll}
 \topline
 \lhdr{Narrow character name} & \chdr{Wide character name} & \rhdr{Corresponding \tcode{ctype_base::mask} value} \\\capsep
 \tcode{"alnum"}  & \tcode{L"alnum"}  & \tcode{ctype_base::alnum}  \\ \rowsep
@@ -2573,7 +2573,7 @@
 \begin{itemdescr}
 \pnum
 \effects\ Move constructs an object of class \tcode{match_results} from \tcode{m}
-satisfying the same postconditions as \tref{re:results:assign}. Additionally,
+satisfying the same postconditions as \tref{re.results.const}. Additionally,
 the stored \tcode{Allocator} value is move constructed from \tcode{m.get_allocator()}.
 
 \pnum
@@ -2588,7 +2588,7 @@
 \begin{itemdescr}
 \pnum
 \effects  Assigns \tcode{m} to \tcode{*this}. The postconditions of this
-function are indicated in \tref{re:results:assign}.
+function are indicated in \tref{re.results.const}.
 \end{itemdescr}
 
 \indexlibrarymember{match_results}{operator=}%
@@ -2599,12 +2599,12 @@
 \begin{itemdescr}
 \pnum
 \effects\ Move-assigns \tcode{m} to \tcode{*this}. The postconditions of this function
-are indicated in \tref{re:results:assign}.
+are indicated in \tref{re.results.const}.
 \end{itemdescr}
 
 \begin{libefftabvalue}
   {\tcode{match_results} assignment operator effects}
-  {tab:re:results:assign}
+  {re.results.const}
 \tcode{ready()}         & \tcode{m.ready()}       \\ \rowsep
 \tcode{size()}          & \tcode{m.size()}        \\ \rowsep
 \tcode{str(n)}          & \tcode{m.str(n)} for all integers \tcode{n < m.size()} \\ \rowsep
@@ -3009,12 +3009,12 @@
 on parameter \tcode{m} is unspecified except that \tcode{m.size()}
 returns \tcode{0} and \tcode{m.empty()} returns \tcode{true}.
 Otherwise the effects on parameter \tcode{m} are given in
-\tref{re:alg:match}.
+\tref{re.alg.match}.
 \end{itemdescr}
 
 \begin{longlibefftabvalue}
   {Effects of \tcode{regex_match} algorithm}
-  {tab:re:alg:match}
+  {re.alg.match}
 \tcode{m.size()}
 &
 \tcode{1 + e.mark_count()}
@@ -3178,12 +3178,12 @@
 If the function returns \tcode{false}, then the effect
 on parameter \tcode{m} is unspecified except that \tcode{m.size()}
 returns \tcode{0} and \tcode{m.empty()} returns \tcode{true}.  Otherwise
-the effects on parameter \tcode{m} are given in \tref{re:alg:search}.
+the effects on parameter \tcode{m} are given in \tref{re.alg.search}.
 \end{itemdescr}
 
 \begin{longlibefftabvalue}
   {Effects of \tcode{regex_search} algorithm}
-  {tab:re:alg:search}
+  {re.alg.search}
 \tcode{m.size()}
 &
 \tcode{1 + e.mark_count()}
@@ -4050,7 +4050,7 @@
 The regular expression grammar may be modified by
 any \tcode{regex_constants::syntax_option_type} flags specified when
 constructing an object of type specialization of \tcode{basic_regex}
-according to the rules in Table \ref{tab:re:syntaxoption}.
+according to the rules in \tref{re.synopt}.
 
 \pnum
 A \tcode{ClassName} production, when used in \tcode{ClassAtomExClass},
diff --git a/source/strings.tex b/source/strings.tex
index a11ff9e813..ee32c1131a 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -15,9 +15,9 @@
 The following subclauses describe a
 character traits class, string classes, and
 null-terminated sequence utilities,
-as summarized in \tref{strings.lib.summary}.
+as summarized in \tref{strings.summary}.
 
-\begin{libsumtab}[x{2.1in}]{Strings library summary}{tab:strings.lib.summary}
+\begin{libsumtab}[x{2.1in}]{Strings library summary}{strings.summary}
 \ref{char.traits}     & Character traits                    & \tcode{<string>}  \\
 \ref{string.classes}  & String classes                      &   \\ \rowsep
 \ref{string.view}     & String view classes                 & \tcode{<string_view>} \\ \rowsep
@@ -69,7 +69,7 @@
 \rSec2[char.traits.require]{Character traits requirements}
 
 \pnum
-In \tref{char.traits.require},
+In \tref{char.traits.req},
 \tcode{X}
 denotes a traits class defining types and functions for the
 character container type
@@ -109,7 +109,7 @@
 
 \begin{libreqtab4d}
 {Character traits requirements}
-{tab:char.traits.require}
+{char.traits.req}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \chdr{Assertion/note}   &   \rhdr{Complexity}\\
                         &                       &   \chdr{pre-/post-condition}   &               \\ \capsep
@@ -223,10 +223,10 @@
 \pnum
 \expects
 \tcode{state_type} meets the
-\oldconcept{Destructible} (\tref{destructible}),
-\oldconcept{CopyAssignable} (\tref{copyassignable}),
-\oldconcept{CopyConstructible} (\tref{copyconstructible}), and
-\oldconcept{DefaultConstructible} (\tref{defaultconstructible}) requirements.
+\oldconcept{Destructible} (\tref{cpp17.destructible}),
+\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}),
+\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}), and
+\oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}) requirements.
 \end{itemdescr}
 
 \rSec2[char.traits.specializations]{\tcode{char_traits} specializations}
@@ -1299,7 +1299,7 @@
 \pnum
 \effects
 Constructs a string from the values in the range \range{begin}{end},
-as indicated in \tref{containers.sequence.requirements}.
+as indicated in \tref{container.seq.req}.
 \end{itemdescr}
 
 \indexlibrary{\idxcode{basic_string}!constructor}%
@@ -4467,7 +4467,7 @@
 \returns
 The nonzero result if the result of the comparison is nonzero.
 Otherwise, returns a value as indicated in \tref{string.view.compare}.
-\begin{libtab2}{\tcode{compare()} results}{tab:string.view.compare}{cc}{Condition}{Return Value}
+\begin{libtab2}{\tcode{compare()} results}{string.view.compare}{cc}{Condition}{Return Value}
 \tcode{size() < str.size()}  & \tcode{< 0}\\
 \tcode{size() == str.size()} & \tcode{ \ 0}\\
 \tcode{size() >  str.size()} & \tcode{> 0}\\
@@ -4804,7 +4804,7 @@
 Let \tcode{S} be \tcode{basic_string_view<charT, traits>}, and \tcode{sv} be an instance of \tcode{S}.
 Implementations shall provide sufficient additional overloads marked \tcode{constexpr} and \tcode{noexcept}
 so that an object \tcode{t} with an implicit conversion to \tcode{S} can be compared according to \tref{string.view.comparison.overloads}.
-\begin{libtab2}{Additional \tcode{basic_string_view} comparison overloads}{tab:string.view.comparison.overloads}{cc}{Expression}{Equivalent to}
+\begin{libtab2}{Additional \tcode{basic_string_view} comparison overloads}{string.view.comparison.overloads}{cc}{Expression}{Equivalent to}
 \tcode{t == sv} & \tcode{S(t) == sv} \\
 \tcode{sv == t} & \tcode{sv == S(t)} \\
 \tcode{t != sv} & \tcode{S(t) != sv} \\
diff --git a/source/styles.tex b/source/styles.tex
index d5b66cbd4a..745b566be3 100644
--- a/source/styles.tex
+++ b/source/styles.tex
@@ -111,22 +111,8 @@
                   leftmargin=\bnfindentrest, listparindent=-\bnfindentinc, itemindent=\listparindent}
 
 %%--------------------------------------------------
-%%  set caption style and delimiter
+%%  set caption style
 \captionstyle{\centering}
-\captiondelim{ --- }
-% override longtable's caption delimiter to match
-\makeatletter
-\def\LT@makecaption#1#2#3{%
-  \LT@mcol\LT@cols c{\hbox to\z@{\hss\parbox[t]\LTcapwidth{%
-    \sbox\@tempboxa{#1{#2 --- }#3}%
-    \ifdim\wd\@tempboxa>\hsize
-      #1{#2 --- }#3%
-    \else
-      \hbox to\hsize{\hfil\box\@tempboxa\hfil}%
-    \fi
-    \endgraf\vskip\baselineskip}%
-  \hss}}}
-\makeatother
 
 %%--------------------------------------------------
 %% set global styles that get reset by \mainmatter
diff --git a/source/support.tex b/source/support.tex
index cef8260c55..0af06909ec 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -20,9 +20,9 @@
 support for contract violation handling,
 support for exception processing, support for initializer lists,
 and other runtime support,
-as summarized in \tref{lang.sup.lib.summary}.
+as summarized in \tref{support.summary}.
 
-\begin{libsumtab}{Language support library summary}{tab:lang.sup.lib.summary}
+\begin{libsumtab}{Language support library summary}{support.summary}
 \ref{support.types}       & Common definitions        &
   \tcode{<cstddef>}, \tcode{<cstdlib>}   \\ \rowsep
 \ref{support.limits}      & Implementation properties &
@@ -518,7 +518,7 @@
 \end{note}
 
 \begin{LongTable}{Standard library feature-test macros}
-{tab:support.ft}{llx{.3\hsize}}
+{support.ft}{llx{.3\hsize}}
 \\ \topline
 \lhdr{Macro name} & \chdr{Value} & \rhdr{Header(s)} \\ \capsep
 \endfirsthead
@@ -3533,7 +3533,7 @@
 
 \pnum
 \tcode{exception_ptr} meets the requirements of
-\oldconcept{NullablePointer} (\tref{nullablepointer}).
+\oldconcept{NullablePointer} (\tref{cpp17.nullablepointer}).
 
 \pnum
 Two non-null values of type \tcode{exception_ptr} are equivalent and compare equal if and
diff --git a/source/tables.tex b/source/tables.tex
index e8de70e598..1d2facbaf3 100644
--- a/source/tables.tex
+++ b/source/tables.tex
@@ -51,7 +51,7 @@
 \newenvironment{floattablebasex}[4]
 {
  \begin{table}[#4]
- \caption{\label{#2}#1}
+ \caption{\label{tab:#2}#1 \quad [tab:#2]}
  \begin{center}
  \begin{tabular}{|#3|}
 }
@@ -164,7 +164,7 @@
 % produces table at current location
 \newenvironment{concepttable}[3]
 {
- \begin{floattablebase}{#1}{tab:#2}{#3}{!htb}
+ \begin{floattablebase}{#1}{#2}{#3}{!htb}
 }
 {
  \end{floattablebase}
@@ -187,7 +187,7 @@
  \newcommand{\continuedcaption}{\caption[]{#1 (continued)}}
  \begin{TableBase}
  \begin{longtable}{|#3|}
- \caption{#1}\label{#2}
+ \caption{#1 \quad [tab:#2]}\label{tab:#2}
 }
 {
  \bottomline
diff --git a/source/templates.tex b/source/templates.tex
index 330388169b..d8fec12d11 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -2754,11 +2754,11 @@
 which evaluates to \tcode{false}.
 \end{example}
 If $N$ is zero for a unary fold-expression,
-the value of the expression is shown in \tref{fold.empty};
-if the operator is not listed in \tref{fold.empty},
+the value of the expression is shown in \tref{temp.fold.empty};
+if the operator is not listed in \tref{temp.fold.empty},
 the instantiation is ill-formed.
 
-\begin{floattable}{Value of folding empty sequences}{tab:fold.empty}
+\begin{floattable}{Value of folding empty sequences}{temp.fold.empty}
 {ll}
 \topline
 \lhdr{Operator} & \rhdr{Value when pack is empty} \\
diff --git a/source/threads.tex b/source/threads.tex
index 29f354143d..db78736614 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -7,9 +7,9 @@
 The following subclauses describe components to create and manage
 threads\iref{intro.multithread}, perform mutual exclusion, and communicate conditions
 and values
-between threads, as summarized in \tref{thread.lib.summary}.
+between threads, as summarized in \tref{thread.summary}.
 
-\begin{libsumtab}{Thread support library summary}{tab:thread.lib.summary}
+\begin{libsumtab}{Thread support library summary}{thread.summary}
 \ref{thread.req}      & Requirements          &                               \\ \rowsep
 \ref{thread.threads}  & Threads               & \tcode{<thread>}              \\ \rowsep
 \ref{thread.mutex}    & Mutual exclusion      &
@@ -3915,7 +3915,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{Alloc} shall satisfy the \oldconcept{Allocator}
-requirements (\tref{utilities.allocator.requirements}).
+requirements (\tref{cpp17.allocator}).
 \end{itemdescr}
 
 
diff --git a/source/time.tex b/source/time.tex
index 5cc00a3c40..1d462318df 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -7,9 +7,9 @@
 \indexlibrary{\idxcode{chrono}}%
 This Clause describes the chrono library\iref{time.syn} and various C
 functions\iref{ctime.syn} that provide generally useful time
-utilities, as summarized in \tref{time.lib.summary}.
+utilities, as summarized in \tref{time.summary}.
 
-\begin{libsumtab}{Time library summary}{tab:time.lib.summary}
+\begin{libsumtab}{Time library summary}{time.summary}
 \ref{time.clock.req}        & \oldconcept{Clock} requirements    & \\ \rowsep
 \ref{time.traits}           & Time-related traits                & \tcode{<chrono>} \\
 \ref{time.duration}         & Class template \tcode{duration}    & \\
@@ -1037,7 +1037,7 @@
 
 \begin{libreqtab3a}
 {\oldconcept{Clock} requirements}
-{tab:time.clock}
+{time.clock}
 \\ \topline
 \lhdr{Expression}       &   \chdr{Return type}  &   \rhdr{Operational semantics} \\ \capsep
 \endfirsthead
@@ -1085,8 +1085,8 @@
 \item \tcode{TC} satisfies the \oldconcept{Clock} requirements\iref{time.clock.req},
 
 \item the types \tcode{TC::rep}, \tcode{TC::duration}, and \tcode{TC::time_point}
-meet the \oldconcept{EqualityComparable} (\tref{equalitycomparable}) and
-\oldconcept{LessThanComparable} (\tref{lessthancomparable})
+meet the \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) and
+\oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable})
 requirements and the requirements of
 numeric types\iref{numeric.requirements}. \begin{note} This means, in particular,
 that operations on these types will not throw exceptions. \end{note}
@@ -3983,8 +3983,8 @@
 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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}),
+\tcode{day} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}),
 and participates in basic arithmetic with \tcode{days} objects,
 which represent a difference between two \tcode{day} objects.
 
@@ -4273,8 +4273,8 @@
 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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}),
+\tcode{month} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}),
 and participates in basic arithmetic with \tcode{months} objects,
 which represent a difference between two \tcode{month} objects.
 
@@ -4583,8 +4583,8 @@
 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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}),
+\tcode{year} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}),
 and participates in basic arithmetic with \tcode{years} objects,
 which represent a difference between two \tcode{year} objects.
 
@@ -4929,7 +4929,7 @@
 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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable}).
+\tcode{weekday} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}).
 \begin{note}
 \tcode{weekday} is not
 \oldconcept{LessThanComparable}
@@ -5493,8 +5493,8 @@
 \pnum
 \tcode{month_day} represents a specific day of a specific month,
 but with an unspecified year.
-\tcode{month_day} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}).
+\tcode{month_day} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \tcode{month_day} is a trivially copyable and standard-layout class type.
@@ -5979,8 +5979,8 @@
 \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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}).
+\tcode{year_month} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}).
 
 \pnum
 \tcode{year_month} is a trivially copyable and standard-layout class type.
@@ -6287,8 +6287,8 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_day} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}),
+\tcode{year_month_day} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}),
 
 \pnum
 \tcode{year_month_day} is a trivially copyable and standard-layout class type.
@@ -6714,8 +6714,8 @@
 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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable})
-and \oldconcept{LessThanComparable} (Table~\ref{tab:lessthancomparable}),
+\tcode{year_month_day_last} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable})
+and \oldconcept{LessThanComparable} (\tref{cpp17.lessthancomparable}),
 
 \pnum
 \tcode{year_month_day_last} is a trivially copyable and standard-layout class type.
@@ -7014,7 +7014,7 @@
 For the latter, there is a conversion to \tcode{sys_days},
 which efficiently supports \tcode{days}-oriented arithmetic.
 \end{note}
-\tcode{year_month_weekday} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable}).
+\tcode{year_month_weekday} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}).
 
 \pnum
 \tcode{year_month_weekday} is a trivially copyable and standard-layout class type.
@@ -7348,7 +7348,7 @@
 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} is \oldconcept{EqualityComparable} (Table~\ref{tab:equalitycomparable}).
+\tcode{year_month_weekday_last} is \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}).
 
 \rSec3[time.cal.ymwdlast.members]{Member functions}
 
@@ -10604,7 +10604,7 @@
 
 \pnum
 Each conversion specifier is replaced by appropriate characters
-as described in Table~\ref{tab:time.format.spec}.
+as described in \tref{time.format.spec}.
 Some of the conversion specifiers
 depend on the locale which is imbued to the \tcode{basic_ostream}.
 If the \tcode{Streamable} object does not contain
@@ -10622,7 +10622,7 @@
 and \tcode{\%Z} or \tcode{\%z} are contained in \tcode{fmt},
 \tcode{os.setstate(ios_base::failbit)} shall be called.
 
-\begin{LongTable}{Meaning of \tcode{format} conversion specifiers}{tab:time.format.spec}{lx{.8\hsize}}
+\begin{LongTable}{Meaning of \tcode{format} conversion specifiers}{time.format.spec}{lx{.8\hsize}}
 \\ \topline
 \lhdr{Specifier} & \rhdr{Replacement} \\ \capsep
 \endfirsthead
@@ -10956,7 +10956,7 @@
 \tcode{setstate(ios_base::failbit)}
 is called on the \tcode{basic_istream}.
 
-\begin{LongTable}{Meaning of \tcode{parse} flags}{tab:time.parse.spec}{lx{.8\hsize}}
+\begin{LongTable}{Meaning of \tcode{parse} flags}{time.parse.spec}{lx{.8\hsize}}
 \\ \topline
 \lhdr{Flag} & \rhdr{Parsed value} \\ \capsep
 \endfirsthead
diff --git a/source/utilities.tex b/source/utilities.tex
index 8fc2b69a74..d60f5204b1 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -6,9 +6,9 @@
 \pnum
 This Clause describes utilities that are generally useful in \Cpp{} programs; some
 of these utilities are used by other elements of the \Cpp{} standard library.
-These utilities are summarized in \tref{util.lib.summary}.
+These utilities are summarized in \tref{utilities.summary}.
 
-\begin{libsumtab}{General utilities library summary}{tab:util.lib.summary}
+\begin{libsumtab}{General utilities library summary}{utilities.summary}
 \ref{utility}               & Utility components                & \tcode{<utility>}     \\
 \ref{intseq}                & Compile-time integer sequences    & \\
 \ref{pairs}                 & Pairs                             & \\ \rowsep
@@ -202,9 +202,9 @@
 Type
 \tcode{T}
 shall be
-\oldconcept{MoveConstructible} (\tref{moveconstructible})
+\oldconcept{MoveConstructible} (\tref{cpp17.moveconstructible})
 and
-\oldconcept{MoveAssignable} (\tref{moveassignable}).
+\oldconcept{MoveAssignable} (\tref{cpp17.moveassignable}).
 
 \pnum
 \effects
@@ -1426,7 +1426,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{Alloc} shall satisfy the
-\oldconcept{Allocator} requirements (\tref{utilities.allocator.requirements}).
+\oldconcept{Allocator} requirements (\tref{cpp17.allocator}).
 
 \pnum
 \effects Equivalent to the preceding constructors except that each element is constructed with
@@ -2086,7 +2086,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{Alloc} shall satisfy the \oldconcept{Allocator}
-requirements (\tref{utilities.allocator.requirements}).
+requirements (\tref{cpp17.allocator}).
 
 \pnum
 \begin{note} Specialization of this trait informs other library components that
@@ -2294,7 +2294,7 @@
 \pnum
 \tcode{T} shall be an object type
 other than \cv{} \tcode{in_place_t} or \cv{} \tcode{nullopt_t}
-and shall satisfy the \oldconcept{Destructible} requirements (\tref{destructible}).
+and shall satisfy the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
 
 \rSec3[optional.ctor]{Constructors}
 
@@ -2586,7 +2586,7 @@
 \pnum
 \effects
 See \tref{optional.assign.copy}.
-\begin{lib2dtab2}{\tcode{optional::operator=(const optional\&)} effects}{tab:optional.assign.copy}
+\begin{lib2dtab2}{\tcode{optional::operator=(const optional\&)} effects}{optional.assign.copy}
 {\tcode{*this} contains a value}
 {\tcode{*this} does not contain a value}
 
@@ -2633,7 +2633,7 @@
 \effects
 See \tref{optional.assign.move}.
 The result of the expression \tcode{bool(rhs)} remains unchanged.
-\begin{lib2dtab2}{\tcode{optional::operator=(optional\&\&)} effects}{tab:optional.assign.move}
+\begin{lib2dtab2}{\tcode{optional::operator=(optional\&\&)} effects}{optional.assign.move}
 {\tcode{*this} contains a value}
 {\tcode{*this} does not contain a value}
 
@@ -2714,7 +2714,7 @@
 \pnum
 \effects
 See \tref{optional.assign.copy.templ}.
-\begin{lib2dtab2}{\tcode{optional::operator=(const optional<U>\&)} effects}{tab:optional.assign.copy.templ}
+\begin{lib2dtab2}{\tcode{optional::operator=(const optional<U>\&)} effects}{optional.assign.copy.templ}
 {\tcode{*this} contains a value}
 {\tcode{*this} does not contain a value}
 
@@ -2776,7 +2776,7 @@
 \effects
 See \tref{optional.assign.move.templ}.
 The result of the expression \tcode{bool(rhs)} remains unchanged.
-\begin{lib2dtab2}{\tcode{optional::operator=(optional<U>\&\&)} effects}{tab:optional.assign.move.templ}
+\begin{lib2dtab2}{\tcode{optional::operator=(optional<U>\&\&)} effects}{optional.assign.move.templ}
 {\tcode{*this} contains a value}
 {\tcode{*this} does not contain a value}
 
@@ -2902,7 +2902,7 @@
 \pnum
 \effects
 See \tref{optional.swap}.
-\begin{lib2dtab2}{\tcode{optional::swap(optional\&)} effects}{tab:optional.swap}
+\begin{lib2dtab2}{\tcode{optional::swap(optional\&)} effects}{optional.swap}
 {\tcode{*this} contains a value}
 {\tcode{*this} does not contain a value}
 
@@ -7359,7 +7359,7 @@
 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 satisfies the
-\oldconcept{Allocator} requirements (\tref{utilities.allocator.requirements}).
+\oldconcept{Allocator} requirements (\tref{cpp17.allocator}).
 
 \rSec2[allocator.uses]{\tcode{uses_allocator}}
 
@@ -9014,7 +9014,7 @@
 
 \pnum
 If the deleter's type \tcode{D} is not a reference type, \tcode{D} shall satisfy
-the \oldconcept{Destructible} requirements (\tref{destructible}).
+the \oldconcept{Destructible} requirements (\tref{cpp17.destructible}).
 
 \pnum
 If the \grammarterm{qualified-id} \tcode{remove_reference_t<D>::pointer} is valid and denotes a
@@ -9022,10 +9022,10 @@
 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
-satisfy the \oldconcept{NullablePointer} requirements (\tref{nullablepointer}).
+satisfy the \oldconcept{NullablePointer} requirements (\tref{cpp17.nullablepointer}).
 
 \pnum
-\begin{example} Given an allocator type \tcode{X} (\tref{utilities.allocator.requirements}) and
+\begin{example} Given an allocator type \tcode{X} (\tref{cpp17.allocator}) and
 letting \tcode{A} be a synonym for \tcode{allocator_traits<X>}, the types \tcode{A::pointer},
 \tcode{A::const_pointer}, \tcode{A::void_pointer}, and \tcode{A::const_void_pointer}
 may be used as \tcode{unique_ptr<T, D>::pointer}. \end{example}
@@ -9041,7 +9041,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{D} shall
-satisfy the \oldconcept{DefaultConstructible} requirements (\tref{defaultconstructible}),
+satisfy the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
 and that construction shall not throw an exception.
 
 \pnum
@@ -9066,7 +9066,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{D} shall
-satisfy the \oldconcept{DefaultConstructible} requirements (\tref{defaultconstructible}),
+satisfy the \oldconcept{DefaultConstructible} requirements (\tref{cpp17.defaultconstructible}),
 and that construction shall not throw an exception.
 
 \pnum
@@ -9146,7 +9146,7 @@
 \pnum
 \requires If \tcode{D} is not a reference type,
 \tcode{D} shall satisfy the \oldconcept{MoveConstructible}
-requirements (\tref{moveconstructible}).
+requirements (\tref{cpp17.moveconstructible}).
 Construction
 of the deleter from an rvalue of type \tcode{D} shall not
 throw an exception.
@@ -9235,7 +9235,7 @@
 \begin{itemdescr}
 \pnum
 \requires If \tcode{D} is not a reference type, \tcode{D} shall satisfy the
-\oldconcept{MoveAssignable} requirements (\tref{moveassignable}) and assignment
+\oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and assignment
 of the deleter from an rvalue of type \tcode{D} shall not throw an exception.
 Otherwise, \tcode{D} is a reference type;
 \tcode{remove_reference_t<D>} shall satisfy the \oldconcept{CopyAssignable}
@@ -10173,7 +10173,7 @@
 The expression \tcode{d(p)}
 shall have well-defined behavior and shall not throw exceptions.
 \tcode{A} shall satisfy the \oldconcept{Allocator} requirements
-(\tref{utilities.allocator.requirements}).
+(\tref{cpp17.allocator}).
 
 \pnum\effects  Constructs a \tcode{shared_ptr} object that owns the
 object \tcode{p} and the deleter \tcode{d}.
@@ -10585,7 +10585,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{A} shall satisfy the \oldconcept{Allocator}
-requirements (\tref{utilities.allocator.requirements}).
+requirements (\tref{cpp17.allocator}).
 
 \pnum
 \effects Allocates memory for an object of type \tcode{T}
@@ -12339,7 +12339,7 @@
 
 \pnum
 A specialization of class template \tcode{pmr::polymorphic_allocator}
-satisfies the \oldconcept{Allocator} requirements (\tref{utilities.allocator.requirements}).
+satisfies the \oldconcept{Allocator} requirements (\tref{cpp17.allocator}).
 Constructed with different memory resources,
 different instances of the same specialization of \tcode{pmr::polymorphic_allocator}
 can exhibit entirely different allocation behavior.
@@ -16017,7 +16017,7 @@
 \ref{func.search} shall satisfy the same requirements and semantics as
 specified in \ref{algorithms.general}.
 Template parameters named \tcode{Hash} shall satisfy the \oldconcept{Hash}
-requirements (\tref{hash}).
+requirements (\tref{cpp17.hash}).
 
 \pnum
 The Boyer-Moore searcher implements the Boyer-Moore search algorithm.
@@ -16315,10 +16315,10 @@
 \pnum
 An enabled specialization \tcode{hash<Key>} will:
 \begin{itemize}
-\item satisfy the \oldconcept{Hash} requirements (\tref{hash}),
+\item satisfy the \oldconcept{Hash} requirements (\tref{cpp17.hash}),
 with \tcode{Key} as the function
-call argument type, the \oldconcept{Default\-Constructible} requirements (\tref{defaultconstructible}),
-the \oldconcept{CopyAssignable} requirements (\tref{copyassignable}),
+call argument type, the \oldconcept{Default\-Constructible} requirements (\tref{cpp17.defaultconstructible}),
+the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}),
 \item be swappable\iref{swappable.requirements} for lvalues,
 \item satisfy 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}
@@ -16884,7 +16884,7 @@
 has a \tcode{value} member that evaluates to \tcode{true}.
 \end{note}
 
-\begin{libreqtab3e}{Primary type category predicates}{tab:type-traits.primary}
+\begin{libreqtab3e}{Primary type category predicates}{meta.unary.cat}
 \\ \topline
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\\capsep
 \endfirsthead
@@ -16964,7 +16964,7 @@
 For any given type \tcode{T}, the result of applying one of these templates to
 \tcode{T} and to \cv{}~\tcode{T} shall yield the same result.
 
-\begin{libreqtab3b}{Composite type category predicates}{tab:type-traits.composite}
+\begin{libreqtab3b}{Composite type category predicates}{meta.unary.comp}
 \\ \topline
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17027,7 +17027,7 @@
 in the context of the corresponding definition
 notwithstanding the restrictions of~\ref{declval}.
 
-\begin{libreqtab3b}{Type property predicates}{tab:type-traits.properties}
+\begin{libreqtab3b}{Type property predicates}{meta.unary.prop}
 \\ \topline
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Preconditions}    \\ \capsep
 \endfirsthead
@@ -17506,7 +17506,7 @@
 This subclause contains templates that may be used to query
 properties of types at compile time.
 
-\begin{libreqtab2a}{Type property queries}{tab:type-traits.properties.queries}
+\begin{libreqtab2a}{Type property queries}{meta.unary.prop.query}
 \\ \topline
 \lhdr{Template} &   \rhdr{Value}    \\ \capsep
 \endfirsthead
@@ -17581,7 +17581,7 @@
 \tcode{true_type} if the corresponding condition is true, otherwise
 \tcode{false_type}.
 
-\begin{libreqtab3f}{Type relationship predicates}{tab:type-traits.relationship}
+\begin{libreqtab3f}{Type relationship predicates}{meta.rel}
 \\ \topline
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17727,7 +17727,7 @@
 
 \rSec3[meta.trans.cv]{Const-volatile modifications}
 
-\begin{libreqtab2a}{Const-volatile modifications}{tab:type-traits.const-volatile}
+\begin{libreqtab2a}{Const-volatile modifications}{meta.trans.cv}
 \\ \topline
 \lhdr{Template} &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17792,7 +17792,7 @@
 
 \rSec3[meta.trans.ref]{Reference modifications}
 
-\begin{libreqtab2a}{Reference modifications}{tab:type-traits.reference}
+\begin{libreqtab2a}{Reference modifications}{meta.trans.ref}
 \\ \topline
 \lhdr{Template} &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17831,7 +17831,7 @@
 \end{libreqtab2a}
 
 \rSec3[meta.trans.sign]{Sign modifications}
-\begin{libreqtab2a}{Sign modifications}{tab:type-traits.sign}
+\begin{libreqtab2a}{Sign modifications}{meta.trans.sign}
 \\ \topline
 \lhdr{Template} &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17876,7 +17876,7 @@
 \end{libreqtab2a}
 
 \rSec3[meta.trans.arr]{Array modifications}
-\begin{libreqtab2a}{Array modifications}{tab:type-traits.array}
+\begin{libreqtab2a}{Array modifications}{meta.trans.arr}
 \\ \topline
 \lhdr{Template} &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17925,7 +17925,7 @@
 \end{example}
 
 \rSec3[meta.trans.ptr]{Pointer modifications}
-\begin{libreqtab2a}{Pointer modifications}{tab:type-traits.pointer}
+\begin{libreqtab2a}{Pointer modifications}{meta.trans.ptr}
 \\ \topline
 \lhdr{Template} &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -17953,7 +17953,7 @@
 
 \rSec3[meta.trans.other]{Other transformations}
 
-\begin{libreqtab2a}{Other transformations}{tab:type-traits.other}
+\begin{libreqtab2a}{Other transformations}{meta.trans.other}
 \\ \topline
 \lhdr{Template}   &   \rhdr{Comments} \\ \capsep
 \endfirsthead
@@ -18627,7 +18627,7 @@
 program is ill-formed unless the implementation yields correct values of \tcode{U} and
 \tcode{V}.
 
-\begin{floattable}{Expressions used to perform ratio arithmetic}{tab:ratio.arithmetic}
+\begin{floattable}{Expressions used to perform ratio arithmetic}{ratio.arithmetic}
 {lll}
 \topline
 \lhdr{Type}                     &