diff --git a/source/basic.tex b/source/basic.tex
index b7e04d53fb..2062fe0cd1 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -511,7 +511,9 @@
 either:
 \begin{itemize}
 \item the intervening scope is a block scope, or
-\item the intervening scope is the function parameter scope of a \grammarterm{lambda-expression}
+\item the intervening scope is the function parameter scope of a \grammarterm{lambda-expression}, or
+\item the intervening scope is the lambda scope of
+a \grammarterm{lambda-expression}
 that has a \grammarterm{simple-capture}
 naming the entity or has a \grammarterm{capture-default}, and
 the block scope of the \grammarterm{lambda-expression}
@@ -2664,28 +2666,18 @@
 
 \pnum
 \indextext{translation unit}%
-A name is said to have \defn{linkage} when it can denote the same
-object, reference, function, type, template, namespace or value as a
-name introduced by a declaration in another scope:
-\begin{itemize}
-\item When a name has \defnadj{external}{linkage},
-the entity it denotes
-can be referred to by names from scopes of other translation units or
-from other scopes of the same translation unit.
-
-\item When a name has \defnx{module linkage}{linkage!module},
-the entity it denotes
-can be referred to by names from other scopes of the same module unit\iref{module.unit} or
-from scopes of other module units of that same module.
-
-\item When a name has \defnadj{internal}{linkage},
-the entity it denotes
-can be referred to by names from other scopes in the same translation
-unit.
-
-\item When a name has \indextext{linkage!no}\defn{no linkage}, the entity it denotes
-cannot be referred to by names from other scopes.
-\end{itemize}
+A name can have
+\defnadj{external}{linkage},
+\defnadj{module}{linkage},
+\defnadj{internal}{linkage}, or
+\defnadj{no}{linkage},
+as determined by the rules below.
+\begin{note}
+All declarations of an entity with a name with internal linkage
+appear in the same translation unit.
+All declarations of an entity with module linkage
+are attached to the same module.
+\end{note}
 
 \pnum
 \indextext{linkage!\idxcode{static} and}%
@@ -2746,6 +2738,24 @@
 has its linkage determined as follows:
 \begin{itemize}
 \item
+\indextext{friend function!linkage of}%
+if the entity is a function or function template
+first declared in a friend declaration and
+that declaration is a definition and
+the enclosing class is defined within an \grammarterm{export-declaration},
+the name has the same linkage, if any,
+as the name of the enclosing class\iref{class.friend};
+\item
+otherwise,
+\indextext{friend function!linkage of}%
+if the entity is a function or function template
+declared in a friend declaration and
+a corresponding non-friend declaration is reachable,
+%FIXME: Which declaration is "that prior declaration"?
+%FIXME: "prior" with respect to what? And what about dependent lookup?
+the name has the linkage determined from that prior declaration,
+\item
+otherwise,
 if the enclosing namespace has internal linkage,
 the name has internal linkage;
 \item
@@ -3450,9 +3460,10 @@
 The \defn{lifetime} of an object or reference is a runtime property of the
 object or reference.
 A variable is said to have \defnadj{vacuous}{initialization}
-if it is default-initialized and,
+if it is default-initialized, no other initialization is performed, and,
 if it is of class type or a (possibly multidimensional) array thereof,
-that class type has a trivial default constructor.
+a trivial constructor of that class type is selected for
+the default-initialization.
 The lifetime of an object of type \tcode{T} begins when:
 \begin{itemize}
 \item storage with the proper alignment and size
@@ -4431,7 +4442,7 @@
 
 \pnum
 When an object of class type \tcode{X}
-is passed to or returned from a function,
+is passed to or returned from a potentially-evaluated function call,
 if \tcode{X} has at least one eligible copy or move constructor\iref{special},
 each such constructor is trivial,
 and the destructor of \tcode{X} is either trivial or deleted,
@@ -4454,11 +4465,6 @@
 \indextext{temporary!constructor for}%
 \indextext{temporary!destructor for}%
 \indextext{temporary!destruction of}%
-When an implementation introduces a temporary object of a class that has a
-non-trivial constructor\iref{class.default.ctor,class.copy.ctor},
-it shall ensure that a constructor is called for the temporary object.
-Similarly, the destructor shall be called for a temporary with a non-trivial
-destructor\iref{class.dtor}.
 Temporary objects are destroyed as the last step
 in evaluating
 the full-expression\iref{intro.execution}
@@ -4476,7 +4482,7 @@
 \pnum
 \indextext{initializer!temporary and declarator}%
 \indextext{temporary!order of destruction of}%
-There are four contexts in which temporaries are destroyed at a different
+There are five contexts in which temporaries are destroyed at a different
 point than the end of the full-expression.
 The first context is when a default constructor is called to initialize
 an element of an array with no corresponding initializer\iref{dcl.init}.
@@ -4602,6 +4608,14 @@
 the object persists for the lifetime of the reference
 initialized by the \grammarterm{for-range-initializer}.
 
+\pnum
+The fifth context is when a temporary object
+is created in a structured binding declaration\iref{dcl.struct.bind}.
+Any temporary objects introduced by
+the \grammarterm{initializer}{s} for the variables
+with unique names
+are destroyed at the end of the structured binding declaration.
+
 \pnum
 Let \tcode{x} and \tcode{y} each be either
 a temporary object whose lifetime is not extended, or
@@ -5760,6 +5774,15 @@
 An extended floating-point type with the same set of values as
 more than one cv-unqualified standard floating-point type
 has a rank equal to the rank of \keyword{double}.
+\begin{tailnote}
+The treatment of \tcode{std::float64_t} differs from
+that of the analoguous \tcode{_Float64} in C,
+for example on platforms where all of
+\tcode{\keyword{long} \keyword{double}},
+\keyword{double}, and
+\tcode{std::float64_t}
+have the same set of values (see \IsoCUndated{}:2024 H.4.2).
+\end{tailnote}
 \end{itemize}
 \begin{note}
 The conversion ranks of floating-point types \tcode{T1} and \tcode{T2}
@@ -5878,7 +5901,8 @@
 \item
 an immediate invocation\iref{expr.const},
 \item
-an \grammarterm{init-declarator}\iref{dcl.decl} or
+an \grammarterm{init-declarator}\iref{dcl.decl}
+(including such introduced by a structured binding\iref{dcl.struct.bind}) or
 a \grammarterm{mem-initializer}\iref{class.base.init},
 including the constituent expressions of the initializer,
 \item
diff --git a/source/classes.tex b/source/classes.tex
index 65b11793d9..d5d733168e 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -1217,7 +1217,7 @@
 has a default argument
 (including the case of a constructor with no parameters).
 \indextext{implicitly-declared default constructor}%
-If there is no user-declared constructor for class
+If there is no user-declared constructor or constructor template for class
 \tcode{X},
 a non-explicit constructor having no parameters is implicitly declared
 as defaulted\iref{dcl.fct.def}.
@@ -4860,12 +4860,6 @@
 \end{codeblock}
 \end{example}
 
-\pnum
-\indextext{friend function!linkage of}%
-A function first declared in a friend declaration
-has the linkage of the namespace of which it is a member\iref{basic.link}.
-Otherwise, the function retains its previous linkage\iref{dcl.stc}.
-
 \pnum
 \indextext{declaration!overloaded name and \tcode{friend}}%
 \begin{note}
diff --git a/source/compatibility.tex b/source/compatibility.tex
index 46fb8d7557..77b08b1d8e 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -1997,6 +1997,28 @@
 \end{codeblock}
 \end{example}
 
+\diffref{expr.typeid}
+\change
+Evaluation of operands in \keyword{typeid}.
+\rationale
+Introduce additional expression value categories.
+\effect
+Valid \CppIII{} code that uses xvalues as operands for \keyword{typeid}
+may change behavior in this revision of \Cpp{}.
+\begin{example}
+\begin{codeblock}
+void f() {
+  struct B {
+    B() {}
+    virtual ~B() { }
+  };
+
+  struct C { B b; };
+  typeid(C().b);    // unevaluated in \CppIII{}, evaluated in \CppXI{}
+}
+\end{codeblock}
+\end{example}
+
 \diffref{expr.mul}
 \change
 Specify rounding for results of integer \tcode{/} and \tcode{\%}.
@@ -2023,6 +2045,31 @@
 \end{codeblock}
 \end{example}
 
+\diffref{expr.cond}
+\change
+Fewer copies in the conditional operator.
+\rationale
+Introduce additional expression value categories.
+\effect
+Valid \CppIII{} code that uses xvalues as operands for the conditional operator
+may change behavior in this revision of \Cpp{}.
+\begin{example}
+\begin{codeblock}
+void f() {
+  struct B {
+    B() {}
+    B(const B&) { }
+  };
+  struct D : B {};
+
+  struct BB { B b; };
+  struct DD { D d; };
+
+  true ? BB().b : DD().d;       // additional copy in \CppIII{}, no copy or move in \CppXI{}
+}
+\end{codeblock}
+\end{example}
+
 \rSec2[diff.cpp03.dcl.dcl]{\ref{dcl.dcl}: declarations}
 
 \diffref{dcl.spec}
diff --git a/source/declarations.tex b/source/declarations.tex
index 220d944f1c..0aeb59b809 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1512,8 +1512,10 @@
 \indextext{name!elaborated!\idxcode{enum}}%
 If an \grammarterm{elaborated-type-specifier} is the sole constituent of a
 declaration, the declaration is ill-formed unless it is an explicit
-specialization\iref{temp.expl.spec}, an explicit
-instantiation\iref{temp.explicit} or it has one of the following
+specialization\iref{temp.expl.spec},
+a partial specialization\iref{temp.spec.partial},
+an explicit
+instantiation\iref{temp.explicit}, or it has one of the following
 forms:
 
 \begin{ncsimplebnf}
@@ -1527,7 +1529,7 @@
 The second case shall appear only
 in an \grammarterm{explicit-specialization}\iref{temp.expl.spec} or
 in a \grammarterm{template-declaration}
-(where it declares a partial specialization\iref{temp.decls}).
+(where it declares a partial specialization).
 The \grammarterm{attribute-specifier-seq}, if any, appertains
 to the class or template being declared.
 
@@ -4629,15 +4631,10 @@
 If
 \tcode{T}
 is a (possibly cv-qualified) class type\iref{class}, then
-\begin{itemize}
-\item
-if \tcode{T} has
-either no default constructor\iref{class.default.ctor} or a default
-constructor that is user-provided or deleted, then the object is default-initialized;
-\item
-otherwise,
-the object is zero-initialized and then default-initialized.
-\end{itemize}
+let \tcode{C} be the constructor selected to
+default-initialize the object, if any.
+If \tcode{C} is not user-provided, the object is first zero-initialized.
+In all cases, the object is then default-initialized.
 
 \item
 If
@@ -4708,7 +4705,7 @@
 The
 \indextext{type!destination}%
 \term{destination type}
-is the type of the object or reference being initialized and the
+is the cv-unqualified type of the object or reference being initialized and the
 \term{source type}
 is the type of the initializer expression.
 If the initializer is not a single (possibly parenthesized) expression, the
@@ -4769,13 +4766,13 @@
 is sequenced before those associated with
 the initialization of the $j^\text{th}$ element.
 \item
-Otherwise, if the destination type is a (possibly cv-qualified) class type:
+Otherwise, if the destination type is a class type:
 
 \begin{itemize}
 \item
 If the initializer expression is a prvalue
 and the cv-unqualified version of the source type
-is the same class as the class of the destination,
+is the same as the destination type,
 the initializer expression is used to initialize the destination object.
 \begin{example}
 \tcode{T x = T(T(T()));} value-initializes \tcode{x}.
@@ -4783,7 +4780,7 @@
 \item
 Otherwise, if the initialization is direct-initialization,
 or if it is copy-initialization where the cv-unqualified version of the source
-type is the same class as, or a derived class of, the class of the destination,
+type is the same as or is derived from the class of the destination type,
 constructors are considered.
 The applicable constructors
 are enumerated\iref{over.match.ctor}, and the best one is chosen
@@ -4880,7 +4877,7 @@
 the (possibly converted) value of the initializer expression.
 A standard conversion sequence\iref{conv} is used
 to convert the initializer expression to
-a prvalue of the cv-unqualified version of
+a prvalue of
 the destination type;
 no user-defined conversions are considered.
 If the conversion cannot
@@ -6263,10 +6260,9 @@
 \item from a floating-point type \tcode{T} to another floating-point type
 whose floating-point conversion rank is neither greater than nor equal to
 that of \tcode{T},
-except where the source is a constant expression and
-the actual value after conversion
-is within the range of values that can be represented (even if it cannot be represented exactly),
-or
+except where the result of the conversion is a constant expression and
+either its value is finite and the conversion did not overflow, or
+the values before and after the conversion are not finite, or
 
 \item from an integer type or unscoped enumeration type to a floating-point type, except
 where the source is a constant expression and the actual value after conversion will fit
@@ -7105,6 +7101,10 @@
 Each $\tcode{v}_i$ is the name of an lvalue of type $\tcode{T}_i$
 that refers to the object bound to $\tcode{r}_i$;
 the referenced type is $\tcode{T}_i$.
+The initialization of \exposid{e} is
+sequenced before the initialization of any $\tcode{r}_i$.
+The initialization of each $\tcode{r}_i$ is
+sequenced before the initialization of any $\tcode{r}_j$ where $i < j$.
 
 \pnum
 Otherwise,
@@ -7477,11 +7477,26 @@
 \pnum
 A \grammarterm{using-enum-declarator}
 names the set of declarations found by
-lookup\iref{basic.lookup.unqual,basic.lookup.qual}
-for the \grammarterm{using-enum-declarator}.
+type-only lookup\iref{basic.lookup.general}
+for the \grammarterm{using-enum-declarator}\iref{basic.lookup.unqual,basic.lookup.qual}.
 The \grammarterm{using-enum-declarator}
 shall designate a non-dependent type
 with a reachable \grammarterm{enum-specifier}.
+\begin{example}
+\begin{codeblock}
+enum E { x };
+void f() {
+  int E;
+  using enum E;                 // OK
+}
+using F = E;
+using enum F;                   // OK
+template<class T> using EE = T;
+void g() {
+  using enum EE<E>;             // OK
+}
+\end{codeblock}
+\end{example}
 
 \pnum
 A \grammarterm{using-enum-declaration}
diff --git a/source/expressions.tex b/source/expressions.tex
index f259fa68d3..cb20e88395 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -1034,16 +1034,26 @@
 The pointer value\iref{basic.compound} is unchanged by this conversion.
 
 \pnum
-A prvalue of type ``pointer to \cv{} \tcode{D}'', where \tcode{D}
+A prvalue \tcode{v} of type ``pointer to \cv{} \tcode{D}'', where \tcode{D}
 is a complete class type, can be converted to a prvalue of type ``pointer to
 \cv{} \tcode{B}'', where \tcode{B} is a base class\iref{class.derived}
 of \tcode{D}. If \tcode{B} is an
 inaccessible\iref{class.access} or
 ambiguous\iref{class.member.lookup} base class of \tcode{D}, a program
-that necessitates this conversion is ill-formed. The result of the
-conversion is a pointer to the base class subobject of the derived class
-object. The null pointer value is converted to the null pointer value of
-the destination type.
+that necessitates this conversion is ill-formed.
+If \tcode{v} is a null pointer value,
+the result is a null pointer value.
+Otherwise,
+if \tcode{B} is a virtual base class of \tcode{D} and
+\tcode{v} does not point to an object
+whose type is similar\iref{conv.qual} to \tcode{D} and
+that is
+within its lifetime or
+within its period of construction or destruction\iref{class.cdtor},
+the behavior is undefined.
+Otherwise,
+the result is a pointer to the base class subobject of
+the derived class object.
 
 \rSec2[conv.mem]{Pointer-to-member conversions}
 
@@ -1155,7 +1165,7 @@
 the following rules are applied:
 \begin{itemize}
 \item
-If both operands have the same type, no further conversion is needed.
+If both operands have the same type, no further conversion is performed.
 \item
 Otherwise, if one of the operands is of a non-floating-point type,
 that operand is converted to the type of
@@ -1257,8 +1267,8 @@
 between the optional
 \grammarterm{cv-qualifier-seq} and the end of the \grammarterm{function-definition},
 \grammarterm{member-declarator}, or \grammarterm{declarator}. It shall not appear within
-the declaration of either
-a static member function or an explicit object member function
+the declaration of
+a static or explicit object member function
 of the current class (although its type and value category
 are defined within such member functions as they are within an implicit object
 member function).
@@ -1903,8 +1913,9 @@
 if the lambda has a \grammarterm{template-parameter-list}.
 \begin{example}
 \begin{codeblock}
-int i = [](int i, auto a) { return i; }(3, 4);                  // OK, a generic lambda
-int j = []<class T>(T t, int i) { return i; }(3, 4);            // OK, a generic lambda
+auto x = [](int i, auto a) { return i; };               // OK, a generic lambda
+auto y = [](this auto self, int i) { return i; };       // OK, a generic lambda
+auto z = []<class T>(int i) { return i; };              // OK, a generic lambda
 \end{codeblock}
 \end{example}
 
@@ -2001,7 +2012,7 @@
 \item
 the closure type,
 \item
-a class type derived from the closure type, or
+a class type publicly and unambiguously derived from the closure type, or
 \item
 a reference to a possibly cv-qualified such type.
 \end{itemize}
@@ -2116,6 +2127,7 @@
 \pnum
 The closure type for a non-generic \grammarterm{lambda-expression} with no
 \grammarterm{lambda-capture}
+and no explicit object parameter\iref{dcl.fct}
 whose constraints (if any) are satisfied
 has a conversion function to pointer to
 function with \Cpp{} language linkage\iref{dcl.link} having
@@ -2136,7 +2148,9 @@
 if the function call operator is an immediate function.
 
 \pnum
-For a generic lambda with no \grammarterm{lambda-capture}, the closure type has a
+For a generic lambda with no \grammarterm{lambda-capture}
+and no explicit object parameter\iref{dcl.fct},
+the closure type has a
 conversion function template to
 pointer to function. The conversion function template has the same invented
 template parameter list, and the pointer to function has the same
@@ -3859,6 +3873,22 @@
 \pnum
 If \tcode{v} is a null pointer value, the result is a null pointer value.
 
+\pnum
+If \tcode{v} has type ``pointer to \cv{}~\tcode{U}'' and
+\tcode{v} does not point to an object
+whose type is similar\iref{conv.qual} to \tcode{U} and
+that is
+within its lifetime or
+within its period of construction or destruction\iref{class.cdtor},
+the behavior is undefined.
+If \tcode{v} is a glvalue of type \tcode{U} and
+\tcode{v} does not refer to an object
+whose type is similar to \tcode{U} and
+that is
+within its lifetime or
+within its period of construction or destruction,
+the behavior is undefined.
+
 \pnum
 If \tcode{T} is ``pointer to \cv{} \keyword{void}'', then the result
 is a pointer to the most derived object pointed to by \tcode{v}.
@@ -4089,7 +4119,22 @@
 a program that necessitates such a cast is ill-formed.
 
 \pnum
-An expression $E$ can be explicitly converted to a type \tcode{T}
+Any expression can be explicitly converted to type \cv{}~\keyword{void},
+in which case the operand is a discarded-value expression\iref{expr.prop}.
+\begin{note}
+Such a \keyword{static_cast} has no result
+as it is a prvalue of type \keyword{void}; see~\ref{basic.lval}.
+\end{note}
+\begin{note}
+However, if the value is in a temporary
+object\iref{class.temporary}, the destructor for that
+object is
+not executed until the usual time, and the value of the object is
+preserved for the purpose of executing the destructor.
+\end{note}
+
+\pnum
+Otherwise, an expression $E$ can be explicitly converted to a type \tcode{T}
 if there is an implicit conversion sequence\iref{over.best.ics}
 from $E$ to \tcode{T},
 if overload resolution for a direct-initialization\iref{dcl.init}
@@ -4117,28 +4162,8 @@
 \end{note}
 
 \pnum
-Otherwise, the \keyword{static_cast} shall perform one of the conversions
-listed below. No other conversion shall be performed explicitly using a
-\keyword{static_cast}.
-
-\pnum
-Any expression can be explicitly converted to type \cv{}~\keyword{void},
-in which case the operand is a discarded-value expression\iref{expr.prop}.
-\begin{note}
-Such a \keyword{static_cast} has no result
-as it is a prvalue of type \keyword{void}; see~\ref{basic.lval}.
-\end{note}
-\begin{note}
-However, if the value is in a temporary
-object\iref{class.temporary}, the destructor for that
-object is
-not executed until the usual time, and the value of the object is
-preserved for the purpose of executing the destructor.
-\end{note}
-
-
-\pnum
-The inverse of any standard conversion sequence\iref{conv} not containing an
+Otherwise,
+the inverse of a standard conversion sequence\iref{conv} not containing an
 lvalue-to-rvalue\iref{conv.lval},
 array-to-pointer\iref{conv.array},
 function-to-pointer\iref{conv.func},
@@ -4282,6 +4307,9 @@
 \end{codeblock}
 \end{example}
 
+\pnum
+No other conversion can be performed using \keyword{static_cast}.
+
 \rSec3[expr.reinterpret.cast]{Reinterpret cast}
 
 \pnum
@@ -5776,22 +5804,15 @@
 If the operand is of
 class type, it is contextually implicitly converted\iref{conv}
 to a pointer to object
-type.
-\begin{footnote}
-This implies that an object
-cannot be deleted using a pointer of type
-\tcode{\keyword{void}*} because \keyword{void} is not an object type.
-\end{footnote}
+type
+and the converted operand is used in place of the original operand
+for the remainder of this subclause.
 Otherwise, it shall be a prvalue of pointer to object type.
 The \grammarterm{delete-expression} has type
 \keyword{void}.
 
 \pnum
 \indextext{\idxcode{delete}!single-object}%
-If the operand has a class type, the operand is converted to a pointer
-type by calling the above-mentioned conversion function, and the
-converted operand is used in place of the original operand for the
-remainder of this subclause.
 In a single-object delete expression, the value of the operand of
 \keyword{delete} may be a null pointer value,
 a pointer value
@@ -5835,10 +5856,6 @@
 expression, if the dynamic type of the object to be deleted is not similar to
 its static type, the behavior is undefined.
 
-\pnum
-The \grammarterm{cast-expression} in a \grammarterm{delete-expression} shall
-be evaluated exactly once.
-
 \pnum
 \indextext{type!incomplete}%
 If the object being deleted has incomplete class type at the point of
@@ -7039,13 +7056,18 @@
 formed and at least one of the operands has (possibly cv-qualified) class type:
 \begin{itemize}
 \item if \tcode{T1} and \tcode{T2} are the same class type
-(ignoring cv-qualification) and
-\tcode{T2} is at least as cv-qualified as \tcode{T1},
-the target type is \tcode{T2},
+(ignoring cv-qualification):
+  \begin{itemize}
+  \item
+  if \tcode{T2} is at least as cv-qualified as \tcode{T1},
+  the target type is \tcode{T2},
+  \item
+  otherwise, no conversion sequence is formed for this operand;
+  \end{itemize}
 
 \item otherwise, if \tcode{T2} is a base class of \tcode{T1},
 the target type is \cvqual{cv1} \tcode{T2}, where \cvqual{cv1}
-denotes the cv-qualifiers of \tcode{T1},
+denotes the cv-qualifiers of \tcode{T1};
 
 \item otherwise, the target type is the type that \tcode{E2} would have
 after applying the
diff --git a/source/intro.tex b/source/intro.tex
index b50e88eeab..3d3b573b17 100644
--- a/source/intro.tex
+++ b/source/intro.tex
@@ -723,15 +723,14 @@
 \item
 If a program contains no violations of the rules in
 \ref{lex} through \ref{\lastlibchapter} as well as those specified in \ref{depr},
-a conforming implementation shall,
-in accordance with the resource limits specified in \ref{implimits},
-accept and correctly execute
+a conforming implementation shall accept and correctly execute
 \begin{footnote}
 ``Correct execution'' can include undefined behavior
 and erroneous behavior, depending on
 the data being processed; see \ref{intro.defs} and~\ref{intro.execution}.
 \end{footnote}
-that program.
+that program,
+except when the implementation's limitations (see below) are exceeded.
 \item
 \indextext{behavior!undefined}%
 If a program contains a violation of a rule for which no diagnostic is required,
@@ -812,6 +811,13 @@
 described in \ref{lex} through \ref{cpp} and
 the subset of the library facilities described in \ref{compliance}.
 
+\pnum
+An implementation is encouraged to document its limitations in
+the size or complexity of the programs it can successfully process,
+if possible and where known.
+\ref{implimits} lists some quantities that can be subject to limitations and
+a potential minimum supported value for each quantity.
+
 \pnum
 A conforming implementation may have extensions (including
 additional library functions), provided they do not alter the
diff --git a/source/lex.tex b/source/lex.tex
index 8ac924c910..cd419e9c25 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -899,7 +899,9 @@
 \tcode{\unun}
 \indextext{character!underscore}%
 or begins with an underscore followed by
-an uppercase letter
+an uppercase letter,
+other than those specified in this document
+(for example, \xname{cplusplus}\iref{cpp.predefined}),
 \indextext{uppercase}%
 is reserved to the implementation for any use.
 \item
@@ -1899,16 +1901,11 @@
 
 \pnum
 \indextext{concatenation!string}%
-The common \grammarterm{encoding-prefix}
-for a sequence of adjacent \grammarterm{string-literal}s
-is determined pairwise as follows.
-If two \grammarterm{string-literal}{s} have
-the same \grammarterm{encoding-prefix},
-the common \grammarterm{encoding-prefix} is that \grammarterm{encoding-prefix}.
-If one \grammarterm{string-literal} has no \grammarterm{encoding-prefix},
-the common \grammarterm{encoding-prefix} is that
-of the other \grammarterm{string-literal}.
-Any other combinations are ill-formed.
+The \grammarterm{string-literal}{s} in
+any sequence of adjacent \grammarterm{string-literal}{s}
+shall have at most one unique \grammarterm{encoding-prefix} among them.
+The common \grammarterm{encoding-prefix} of the sequence is
+that \grammarterm{encoding-prefix}, if any.
 \begin{note}
 A \grammarterm{string-literal}'s rawness has
 no effect on the determination of the common \grammarterm{encoding-prefix}.
diff --git a/source/limits.tex b/source/limits.tex
index ca3953634b..bdc1f3deb6 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -1,22 +1,11 @@
 %!TEX root = std.tex
-\normannex{implimits}{Implementation quantities}
+\infannex{implimits}{Implementation quantities}
 
 \pnum
-Because computers are finite, \Cpp{}  implementations are inevitably
-limited in the size of the programs they can successfully process.
-Every implementation shall
-document those limitations where known.
-This documentation may cite fixed limits where they
-exist, say how to compute variable limits as a function
-of available resources, or say that fixed limits do not exist
-or are unknown.
-
-\pnum
-The following list describes quantities that, among others, may be
-constrained by implementations.
-The bracketed number following each quantity is recommended
-as the minimum for that quantity.
-However, these quantities are only guidelines and do not determine compliance.
+Implementations can exhibit limitations for various quantities;
+some possibilities are presented in the following list.
+The bracketed number following each quantity is
+a potential minimum value for that quantity.
 \begin{itemize}
 \item%
 Nesting levels of compound statements\iref{stmt.block},
diff --git a/source/overloading.tex b/source/overloading.tex
index 9e1292a793..d7cac76f7c 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -1734,10 +1734,10 @@
 (see~\ref{dcl.init},
 \ref{over.match.conv}, and~\ref{over.match.ref})
 and the standard conversion sequence
-from the return type of $\tcode{F}_1$ to the destination type
+from the result of $\tcode{F}_1$ to the destination type
 (i.e., the type of the entity being initialized)
 is a better conversion sequence than the standard conversion sequence
-from the return type of $\tcode{F}_2$ to the destination type
+from the result of $\tcode{F}_2$ to the destination type
 \begin{example}
 \begin{codeblock}
 struct A {
@@ -2792,7 +2792,7 @@
 (where a standard conversion sequence that is a reference binding
 is considered to yield the cv-unqualified referenced type),
 where \tcode{T1} and \tcode{T2} are not the same type, and
-\tcode{const T2} is reference-compatible with \tcode{T1}\iref{dcl.init.ref}.
+\tcode{const T2} is reference-compatible with \tcode{T1}\iref{dcl.init.ref}
 \begin{example}
 \begin{codeblock}
 int f(const volatile int *);
@@ -2806,6 +2806,7 @@
 \end{codeblock}
 \end{example}
 or, if not that,
+
 \item
 \tcode{S1}
 and
@@ -2813,7 +2814,7 @@
 bind ``reference to \tcode{T1}'' and ``reference to \tcode{T2}'',
 respectively\iref{dcl.init.ref},
 where \tcode{T1} and \tcode{T2} are not the same type, and
-\tcode{T2} is reference-compatible with \tcode{T1}.
+\tcode{T2} is reference-compatible with \tcode{T1}
 \begin{example}
 \begin{codeblock}
 int f(const int &);
@@ -2846,6 +2847,32 @@
 }
 \end{codeblock}
 \end{example}
+or, if not that,
+
+\item
+\tcode{S1} and \tcode{S2}
+bind the same reference type ``reference to \tcode{T}'' and
+have source types \tcode{V1} and \tcode{V2}, respectively,
+where the standard conversion sequence from \tcode{V1*} to \tcode{T*}
+is better than the standard conversion sequence from \tcode{V2*} to \tcode{T*}.
+\begin{example}
+\begin{codeblock}
+struct Z {};
+
+struct A {
+  operator Z&();
+  operator const Z&();          // \#1
+};
+
+struct B {
+  operator Z();
+  operator const Z&&();         // \#2
+};
+
+const Z& r1 = A();              // OK, uses \#1
+const Z&& r2 = B();             // OK, uses \#2
+\end{codeblock}
+\end{example}
 \end{itemize}
 
 \item
diff --git a/source/templates.tex b/source/templates.tex
index 480f6dc0e5..23e8f391db 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -7445,6 +7445,13 @@
 Attempting to create a function type in which a parameter has a type
 of \keyword{void}, or in which the return type is a function type
 or array type.
+
+\item
+%FIXME: What's it mean to "give" a type "to" a parameter?
+%FIXME: See also "Attempting to give an invalid type to ..." above.
+Attempting to give to
+an explicit object parameter of a lambda's function call operator
+a type not permitted for such\iref{expr.prim.lambda.closure}.
 \end{itemize}
 \end{note}