Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision 5546eee4176e12f525c30034b085e9e000cdba20)
+++ doc/user/user.tex	(revision 479fbe377d83fb9941a02a57b51b980995a449d1)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sat Sep 30 22:46:19 2023
-%% Update Count     : 5658
+%% Last Modified On : Sun Jan 14 17:27:41 2024
+%% Update Count     : 5764
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -55,8 +55,7 @@
 \SetWatermarkLightness{0.9}
 
-% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
-% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
-% AFTER HYPERREF.
-\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+% Default underscore is too low. Cannot use lstlisting "literate" as replacing underscore removes it
+% as a variable-name character so keywords in variables are highlighted. MUST APPEAR AFTER HYPERREF.
+\renewcommand{\textunderscore}{\makebox[1.4ex][c]{{\raisebox{1.25pt}{\char`\_}}}}
 
 \setlength{\topmargin}{-0.45in}							% move running title into header
@@ -67,5 +66,5 @@
 \CFAStyle												% use default CFA format-style
 \setgcolumn{2.25in}
-%\lstset{language=CFA}									% CFA default lnaguage
+\lstset{language=CFA}									% CFA default lnaguage
 \lstnewenvironment{C++}[1][]                            % use C++ style
 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
@@ -172,6 +171,6 @@
 \begin{tabular}{@{}lll@{}}
 \multicolumn{1}{@{}c}{\textbf{C}}	& \multicolumn{1}{c}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{\CC}}	\\
-\begin{cfa}[tabsize=3]
-#include <stdio.h>$\indexc{stdio.h}$
+\begin{cfa}
+#include <stdio.h>§\indexc{stdio.h}§
 
 int main( void ) {
@@ -182,14 +181,14 @@
 &
 \begin{cfa}[tabsize=3]
-#include <fstream>$\indexc{fstream}$
+#include <fstream>§\indexc{fstream}§
 
 int main( void ) {
 	int x = 0, y = 1, z = 2;
-	®sout | x | y | z;®$\indexc{sout}$
+	®sout | x | y | z;®§\indexc{sout}§
 }
 \end{cfa}
 &
 \begin{cfa}[tabsize=3]
-#include <iostream>$\indexc{iostream}$
+#include <iostream>§\indexc{iostream}§
 using namespace std;
 int main() {
@@ -260,5 +259,5 @@
 \begin{cfa}
 ®forall( T )® T identity( T val ) { return val; }
-int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
+int forty_two = identity( 42 ); §\C{// T is bound to int, forty\_two == 42}§
 \end{cfa}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
@@ -288,5 +287,5 @@
 
 double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
-double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$
+double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§
 \end{cfa}
 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
@@ -297,8 +296,8 @@
 
 forall( T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
-	T * result = bsearch( key, arr, size ); $\C{// call first version}$
-	return result ? result - arr : size; } $\C{// pointer subtraction includes sizeof(T)}$
-
-double * val = bsearch( 5.0, vals, 10 ); $\C{// selection based on return type}$
+	T * result = bsearch( key, arr, size ); §\C{// call first version}§
+	return result ? result - arr : size; } §\C{// pointer subtraction includes sizeof(T)}§
+
+double * val = bsearch( 5.0, vals, 10 ); §\C{// selection based on return type}§
 int posn = bsearch( 5.0, vals, 10 );
 \end{cfa}
@@ -312,5 +311,5 @@
 \begin{cfa}
 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
-int * ip = malloc(); $\C{// select type and size from left-hand side}$
+int * ip = malloc(); §\C{// select type and size from left-hand side}§
 double * dp = malloc();
 struct S {...} * sp = malloc();
@@ -324,5 +323,5 @@
 \begin{cfa}
 char ®abs®( char );
-extern "C" { int ®abs®( int ); } $\C{// use default C routine for int}$
+extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§
 long int ®abs®( long int );
 long long int ®abs®( long long int );
@@ -349,5 +348,5 @@
 The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
 \begin{cfa}
-cfa$\indexc{cfa}\index{compilation!cfa@©cfa©}$ [ gcc/$\CFA{}$-options ] [ C/$\CFA{}$ source-files ] [ assembler/loader files ]
+cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc/§\CFA{}§-options ] [ C/§\CFA{}§ source-files ] [ assembler/loader files ]
 \end{cfa}
 There is no ordering among options (flags) and files, unless an option has an argument, which must appear immediately after the option possibly with or without a space separating option and argument.
@@ -438,7 +437,7 @@
 \begin{cfa}
 #ifndef __CFORALL__
-#include <stdio.h>$\indexc{stdio.h}$ $\C{// C header file}$
+#include <stdio.h>§\indexc{stdio.h}§ §\C{// C header file}§
 #else
-#include <fstream>$\indexc{fstream}$ $\C{// \CFA header file}$
+#include <fstream>§\indexc{fstream}§ §\C{// \CFA header file}§
 #endif
 \end{cfa}
@@ -450,10 +449,10 @@
 Each option must be escaped with \Indexc{-XCFA}\index{translator option!-XCFA@{©-XCFA©}} to direct it to the compiler step, similar to the ©-Xlinker© flag for the linker, \eg:
 \begin{lstlisting}[language=sh]
-cfa $test$.cfa -CFA -XCFA -p # print translated code without printing the standard prelude
-cfa $test$.cfa -XCFA -P -XCFA parse -XCFA -n # show program parse without prelude
+cfa §test§.cfa -CFA -XCFA -p # print translated code without printing the standard prelude
+cfa §test§.cfa -XCFA -P -XCFA parse -XCFA -n # show program parse without prelude
 \end{lstlisting}
-Alternatively, multiple flages can be specified separated with commas and \emph{without} spaces.
+Alternatively, multiple flags can be specified separated with commas and \emph{without} spaces.
 \begin{lstlisting}[language=sh,{moredelim=**[is][\protect\color{red}]{®}{®}}]
-cfa $test$.cfa -XCFA®,®-Pparse®,®-n # show program parse without prelude
+cfa §test§.cfa -XCFA®,®-Pparse®,®-n # show program parse without prelude
 \end{lstlisting}
 \begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt]
@@ -537,5 +536,5 @@
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
-int ®``®coroutine = 3;					$\C{// make keyword an identifier}$
+int ®``®coroutine = 3;					§\C{// make keyword an identifier}§
 double ®``®forall = 3.5;
 \end{cfa}
@@ -547,10 +546,10 @@
 \begin{cfa}
 // include file uses the CFA keyword "with".
-#if ! defined( with )					$\C{// nesting ?}$
-#define with ®``®with					$\C{// make keyword an identifier}$
+#if ! defined( with )					§\C{// nesting ?}§
+#define with ®``®with					§\C{// make keyword an identifier}§
 #define __CFA_BFD_H__
 #endif
-$\R{\#include\_next} <bfdlink.h>$		$\C{// must have internal check for multiple expansion}$
-#if defined( with ) && defined( __CFA_BFD_H__ )	$\C{// reset only if set}$
+§\R{\#include\_next} <bfdlink.h>§		§\C{// must have internal check for multiple expansion}§
+#if defined( with ) && defined( __CFA_BFD_H__ )	§\C{// reset only if set}§
 #undef with
 #undef __CFA_BFD_H__
@@ -566,14 +565,14 @@
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg:
 \begin{cfa}
-2®_®147®_®483®_®648;					$\C{// decimal constant}$
-56®_®ul;								$\C{// decimal unsigned long constant}$
-0®_®377;								$\C{// octal constant}$
-0x®_®ff®_®ff;							$\C{// hexadecimal constant}$
-0x®_®ef3d®_®aa5c;						$\C{// hexadecimal constant}$
-3.141®_®592®_®654;						$\C{// floating constant}$
-10®_®e®_®+1®_®00;					 	$\C{// floating constant}$
-0x®_®ff®_®ff®_®p®_®3;					$\C{// hexadecimal floating}$
-0x®_®1.ffff®_®ffff®_®p®_®128®_®l;		$\C{// hexadecimal floating long constant}$
-L®_®$"\texttt{\textbackslash{x}}$®_®$\texttt{ff}$®_®$\texttt{ee}"$; $\C{// wide character constant}$
+2®_®147®_®483®_®648;					§\C{// decimal constant}§
+56®_®ul;								§\C{// decimal unsigned long constant}§
+0®_®377;								§\C{// octal constant}§
+0x®_®ff®_®ff;							§\C{// hexadecimal constant}§
+0x®_®ef3d®_®aa5c;						§\C{// hexadecimal constant}§
+3.141®_®592®_®654;						§\C{// floating constant}§
+10®_®e®_®+1®_®00;					 	§\C{// floating constant}§
+0x®_®ff®_®ff®_®p®_®3;					§\C{// hexadecimal floating}§
+0x®_®1.ffff®_®ffff®_®p®_®128®_®l;		§\C{// hexadecimal floating long constant}§
+L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§; §\C{// wide character constant}§
 \end{cfa}
 The rules for placement of underscores are:
@@ -635,13 +634,13 @@
 Declarations in the \Indexc{do}-©while© condition are not useful because they appear after the loop body.}
 \begin{cfa}
-if ( ®int x = f()® ) ...			$\C{// x != 0}$
-if ( ®int x = f(), y = g()® ) ...	$\C{// x != 0 \&\& y != 0}$
-if ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
-if ( ®struct S { int i; } x = { f() }; x.i < 4® ) $\C{// relational expression}$
-
-while ( ®int x = f()® ) ...			$\C{// x != 0}$
-while ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
-while ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
-while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... $\C{// relational expression}$
+if ( ®int x = f()® ) ...			§\C{// x != 0}§
+if ( ®int x = f(), y = g()® ) ...	§\C{// x != 0 \&\& y != 0}§
+if ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
+if ( ®struct S { int i; } x = { f() }; x.i < 4® ) §\C{// relational expression}§
+
+while ( ®int x = f()® ) ...			§\C{// x != 0}§
+while ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§
+while ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
+while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... §\C{// relational expression}§
 \end{cfa}
 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical \Indexc{&&} operator.
@@ -713,7 +712,7 @@
 \begin{cfa}
 switch ( i ) {
-  case 1$\R{\textvisiblespace}$®...®4:
+  case 1§\R{\textvisiblespace}§®...®4:
 	...
-  case 10$\R{\textvisiblespace}$®...®13:
+  case 10§\R{\textvisiblespace}§®...®13:
 	...
 }
@@ -752,5 +751,5 @@
   case 1:
 	...
-	$\R{\LstCommentStyle{// fall-through}}$
+	§\R{\LstCommentStyle{// fall-through}}§
   case 2:
 	...
@@ -853,12 +852,12 @@
 \begin{cfa}
 switch ( x ) {
-	®int y = 1;® $\C{// unreachable initialization}$
-	®x = 7;® $\C{// unreachable code without label/branch}$
+	®int y = 1;® §\C{// unreachable initialization}§
+	®x = 7;® §\C{// unreachable code without label/branch}§
   case 0: ...
 	...
-	®int z = 0;® $\C{// unreachable initialization, cannot appear after case}$
+	®int z = 0;® §\C{// unreachable initialization, cannot appear after case}§
 	z = 2;
   case 1:
-	®x = z;® $\C{// without fall through, z is uninitialized}$
+	®x = z;® §\C{// without fall through, z is uninitialized}§
 }
 \end{cfa}
@@ -895,11 +894,11 @@
   case 1:  case 2:  case 3:
 	...
-	$\R{\LstCommentStyle{// implicit end of switch (break)}}$
+	§\R{\LstCommentStyle{// implicit end of switch (break)}}§
   case 5:
 	...
-	®fallthru®; $\C{// explicit fall through}$
+	®fallthru®; §\C{// explicit fall through}§
   case 7:
 	...
-	®break® $\C{// explicit end of switch (redundant)}$
+	®break® §\C{// explicit end of switch (redundant)}§
   default:
 	j = 3;
@@ -922,13 +921,13 @@
 \begin{cfa}
 switch ( x ) {
-	®int i = 0;®						$\C{// allowed only at start}$
+	®int i = 0;®						§\C{// allowed only at start}§
   case 0:
 	...
-	®int j = 0;®						$\C{// disallowed}$
+	®int j = 0;®						§\C{// disallowed}§
   case 1:
 	{
-		®int k = 0;®					$\C{// allowed at different nesting levels}$
+		®int k = 0;®					§\C{// allowed at different nesting levels}§
 		...
-	  ®case 2:®							$\C{// disallow case in nested statements}$
+	  ®case 2:®							§\C{// disallow case in nested statements}§
 	}
   ...
@@ -1004,47 +1003,47 @@
 while () { sout | "empty"; break; }
 do { sout | "empty"; break; } while ();
-for () { sout | "empty"; break; }							$\C[3in]{sout | nl | nlOff;}$
-
-for ( 0 ) { sout | "A"; } sout | "zero";					$\C{sout | nl;}$
-for ( 1 ) { sout | "A"; }									$\C{sout | nl;}$
-for ( 10 ) { sout | "A"; }									$\C{sout | nl;}$
-for ( ~= 10 ) { sout | "A"; }								$\C{sout | nl;}$
-for ( 1 ~= 10 ~ 2 ) { sout | "B"; }							$\C{sout | nl;}$
-for ( 1 -~= 10 ~ 2 ) { sout | "C"; }						$\C{sout | nl;}$
-for ( 0.5 ~ 5.5 ) { sout | "D"; }							$\C{sout | nl;}$
-for ( 0.5 -~ 5.5 ) { sout | "E"; }							$\C{sout | nl;}$
-for ( i; 10 ) { sout | i; }									$\C{sout | nl;}$
-for ( i; ~= 10 ) { sout | i; }								$\C{sout | nl;}$
-for ( i; 1 ~= 10 ~ 2 ) { sout | i; }						$\C{sout | nl;}$
-for ( i; 1 -~= 10 ~ 2 ) { sout | i; }						$\C{sout | nl;}$
-for ( i; 0.5 ~ 5.5 ) { sout | i; }							$\C{sout | nl;}$
-for ( i; 0.5 -~ 5.5 ) { sout | i; }							$\C{sout | nl;}$
-for ( ui; 2u ~= 10u ~ 2u ) { sout | ui; }					$\C{sout | nl;}$
-for ( ui; 2u -~= 10u ~ 2u ) { sout | ui; }					$\C{sout | nl | nl | nl;}$
+for () { sout | "empty"; break; }							§\C[3in]{sout | nl | nlOff;}§
+
+for ( 0 ) { sout | "A"; } sout | "zero";					§\C{sout | nl;}§
+for ( 1 ) { sout | "A"; }									§\C{sout | nl;}§
+for ( 10 ) { sout | "A"; }									§\C{sout | nl;}§
+for ( ~= 10 ) { sout | "A"; }								§\C{sout | nl;}§
+for ( 1 ~= 10 ~ 2 ) { sout | "B"; }							§\C{sout | nl;}§
+for ( 1 -~= 10 ~ 2 ) { sout | "C"; }						§\C{sout | nl;}§
+for ( 0.5 ~ 5.5 ) { sout | "D"; }							§\C{sout | nl;}§
+for ( 0.5 -~ 5.5 ) { sout | "E"; }							§\C{sout | nl;}§
+for ( i; 10 ) { sout | i; }									§\C{sout | nl;}§
+for ( i; ~= 10 ) { sout | i; }								§\C{sout | nl;}§
+for ( i; 1 ~= 10 ~ 2 ) { sout | i; }						§\C{sout | nl;}§
+for ( i; 1 -~= 10 ~ 2 ) { sout | i; }						§\C{sout | nl;}§
+for ( i; 0.5 ~ 5.5 ) { sout | i; }							§\C{sout | nl;}§
+for ( i; 0.5 -~ 5.5 ) { sout | i; }							§\C{sout | nl;}§
+for ( ui; 2u ~= 10u ~ 2u ) { sout | ui; }					§\C{sout | nl;}§
+for ( ui; 2u -~= 10u ~ 2u ) { sout | ui; }					§\C{sout | nl | nl | nl;}§
 
 enum { N = 10 };
-for ( N ) { sout | "N"; }									$\C{sout | nl;}$
-for ( i; N ) { sout | i; }									$\C{sout | nl;}$
-for ( i; -~ N ) { sout | i; }								$\C{sout | nl | nl | nl;}$
+for ( N ) { sout | "N"; }									§\C{sout | nl;}§
+for ( i; N ) { sout | i; }									§\C{sout | nl;}§
+for ( i; -~ N ) { sout | i; }								§\C{sout | nl | nl | nl;}§
 
 const int low = 3, high = 10, inc = 2;
-for ( i; low ~ high ~ inc + 1 ) { sout | i; }				$\C{sout | nl;}$
-for ( i; 1 ~ @ ) { if ( i > 10 ) break; sout | i; }			$\C{sout | nl;}$
-for ( i; @ -~ 10 ) { if ( i < 0 ) break; sout | i; }		$\C{sout | nl;}$
-for ( i; 2 ~ @ ~ 2 ) { if ( i > 10 ) break; sout | i; }		$\C{sout | nl;}$
-for ( i; 2.1 ~ @ ~ @ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; } $\C{sout | nl;}$
-for ( i; @ -~ 10 ~ 2 ) { if ( i < 0 ) break; sout | i; }	$\C{sout | nl;}$
-for ( i; 12.1 ~ @ ~ @ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; } $\C{sout | nl;}$
-for ( i; 5 : j; -5 ~ @ ) { sout | i | j; }					$\C{sout | nl;}$
-for ( i; 5 : j; @ -~ -5 ) { sout | i | j; }					$\C{sout | nl;}$
-for ( i; 5 : j; -5 ~ @ ~ 2 ) { sout | i | j; }				$\C{sout | nl;}$
-for ( i; 5 : j; @ -~ -5 ~ 2 ) { sout | i | j; }				$\C{sout | nl;}$
-for ( i; 5 : j; -5 ~ @ ) { sout | i | j; }					$\C{sout | nl;}$
-for ( i; 5 : j; @ -~ -5 ) { sout | i | j; }					$\C{sout | nl;}$
-for ( i; 5 : j; -5 ~ @ ~ 2 ) { sout | i | j; }				$\C{sout | nl;}$
-for ( i; 5 : j; @ -~ -5 ~ 2 ) { sout | i | j; }				$\C{sout | nl;}$
-for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } $\C{sout | nl;}$
-for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } $\C{sout | nl;}$
-for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } $\C{sout | nl;}\CRT$
+for ( i; low ~ high ~ inc + 1 ) { sout | i; }				§\C{sout | nl;}§
+for ( i; 1 ~ @ ) { if ( i > 10 ) break; sout | i; }			§\C{sout | nl;}§
+for ( i; @ -~ 10 ) { if ( i < 0 ) break; sout | i; }		§\C{sout | nl;}§
+for ( i; 2 ~ @ ~ 2 ) { if ( i > 10 ) break; sout | i; }		§\C{sout | nl;}§
+for ( i; 2.1 ~ @ ~ @ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; } §\C{sout | nl;}§
+for ( i; @ -~ 10 ~ 2 ) { if ( i < 0 ) break; sout | i; }	§\C{sout | nl;}§
+for ( i; 12.1 ~ @ ~ @ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; } §\C{sout | nl;}§
+for ( i; 5 : j; -5 ~ @ ) { sout | i | j; }					§\C{sout | nl;}§
+for ( i; 5 : j; @ -~ -5 ) { sout | i | j; }					§\C{sout | nl;}§
+for ( i; 5 : j; -5 ~ @ ~ 2 ) { sout | i | j; }				§\C{sout | nl;}§
+for ( i; 5 : j; @ -~ -5 ~ 2 ) { sout | i | j; }				§\C{sout | nl;}§
+for ( i; 5 : j; -5 ~ @ ) { sout | i | j; }					§\C{sout | nl;}§
+for ( i; 5 : j; @ -~ -5 ) { sout | i | j; }					§\C{sout | nl;}§
+for ( i; 5 : j; -5 ~ @ ~ 2 ) { sout | i | j; }				§\C{sout | nl;}§
+for ( i; 5 : j; @ -~ -5 ~ 2 ) { sout | i | j; }				§\C{sout | nl;}§
+for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§
+for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§
+for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}\CRT§
 \end{cfa}
 &
@@ -1117,7 +1116,7 @@
 The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control allow an empty conditional, which implies a comparison value of ©1© (true).
 \begin{cfa}
-while ( ®/* empty */®  )				$\C{// while ( true )}$
-for ( ®/* empty */®  )					$\C{// for ( ; true; )}$
-do ... while ( ®/* empty */®  )			$\C{// do ... while ( true )}$
+while ( ®/* empty */®  )				§\C{// while ( true )}§
+for ( ®/* empty */®  )					§\C{// for ( ; true; )}§
+do ... while ( ®/* empty */®  )			§\C{// do ... while ( true )}§
 \end{cfa}
 
@@ -1149,7 +1148,7 @@
 If no type is specified for the loop index, it is the type of the high value H (when the low value is implicit) or the low value L.
 \begin{cfa}
-for ( ®5® )								$\C{// typeof(5) anonymous-index; 5 is high value}$
-for ( i; ®1.5® ~ 5.5 )					$\C{// typeof(1.5) i; 1.5 is low value}$
-for ( ®int i®; 0 ~ 10 ~ 2 )				$\C{// int i; type is explicit}$
+for ( ®5® )								§\C{// typeof(5) anonymous-index; 5 is high value}§
+for ( i; ®1.5® ~ 5.5 )					§\C{// typeof(1.5) i; 1.5 is low value}§
+for ( ®int i®; 0 ~ 10 ~ 2 )				§\C{// int i; type is explicit}§
 \end{cfa}
 
@@ -1159,37 +1158,37 @@
 H is implicit up-to exclusive range [0,H\R{)}.
 \begin{cfa}
-for ( ®5® )								$\C{// for ( typeof(5) i; i < 5; i += 1 )}$
+for ( ®5® )								§\C{// for ( typeof(5) i; i < 5; i += 1 )}§
 \end{cfa}
 \item
 ©~=© H is implicit up-to inclusive range [0,H\R{]}.
 \begin{cfa}
-for ( ®~=® 5 )							$\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
+for ( ®~=® 5 )							§\C{// for ( typeof(5) i; i <= 5; i += 1 )}§
 \end{cfa}
 \item
 L ©~©\index{~@©~©} H is explicit up-to exclusive range [L,H\R{)}.
 \begin{cfa}
-for ( 1 ®~® 5 )							$\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
+for ( 1 ®~® 5 )							§\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}§
 \end{cfa}
 \item
 L ©~=©\index{~=@©~=©} H is explicit up-to inclusive range [L,H\R{]}.
 \begin{cfa}
-for ( 1 ®~=® 5 )						$\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
+for ( 1 ®~=® 5 )						§\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}§
 \end{cfa}
 \item
 L ©-~©\index{-~@©-~©} H is explicit down-to exclusive range [H,L\R{)}, where L and H are implicitly interchanged to make the range down-to.
 \begin{cfa}
-for ( 1 ®-~® 5 )						$\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
+for ( 1 ®-~® 5 )						§\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}§
 \end{cfa}
 \item
 L ©-~=©\index{-~=@©-~=©} H is explicit down-to inclusive range [H,L\R{]}, where L and H are implicitly interchanged to make the range down-to.
 \begin{cfa}
-for ( 1 ®-~=® 5 )						$\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
+for ( 1 ®-~=® 5 )						§\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}§
 \end{cfa}
 \item
 ©@© means put nothing in this field.
 \begin{cfa}
-for ( i; 1 ~ ®@® ~ 2 )					$\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}$
-for ( i; 1 ~ 10 ~ ®@® )					$\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}$
-for ( i; 1 ~ ®@® ~ ®@® )				$\C{// for ( typeof(1) i = 1; /*empty*/; \R{/* empty */} )}$
+for ( i; 1 ~ ®@® ~ 2 )					§\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}§
+for ( i; 1 ~ 10 ~ ®@® )					§\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}§
+for ( i; 1 ~ ®@® ~ ®@® )				§\C{// for ( typeof(1) i = 1; /*empty*/; \R{/* empty */} )}§
 \end{cfa}
 L cannot be elided for the up-to range, \lstinline{@ ~ 5}, and H for the down-to range, \lstinline{1 -~ @}, because then the loop index is uninitialized.
@@ -1198,12 +1197,12 @@
 ©:© means low another index.
 \begin{cfa}
-for ( i; 5 ®:® j; 2 ~ 12 ~ 3 )			$\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}$
+for ( i; 5 ®:® j; 2 ~ 12 ~ 3 )			§\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}§
 \end{cfa}
 \end{itemize}
 \R{Warning}: specifying the down-to range maybe unexpected because the loop control \emph{implicitly} switches the L and H values (and toggles the increment/decrement for I):
 \begin{cfa}
-for ( i; 1 ~ 10 )						${\C{// up range}$
-for ( i; 1 -~ 10 )						${\C{// down range}$
-for ( i; ®10 -~ 1® )					${\C{// \R{WRONG down range!}}}$
+for ( i; 1 ~ 10 )						§{\C{// up range}§
+for ( i; 1 -~ 10 )						§{\C{// down range}§
+for ( i; ®10 -~ 1® )					§{\C{// \R{WRONG down range!}}}§
 \end{cfa}
 The reason for this semantics is that the range direction can be toggled by adding/removing the minus, ©'-'©, versus interchanging the L and H expressions, which has a greater chance of introducing errors.
@@ -1361,9 +1360,9 @@
 Grouping heterogeneous data into an \newterm{aggregate} (structure/union) is a common programming practice, and aggregates may be nested:
 \begin{cfa}
-struct Person {							$\C{// aggregate}$
-	struct Name {						$\C{// nesting}$
+struct Person {							§\C{// aggregate}§
+	struct Name {						§\C{// nesting}§
 		char first[20], last[20];
 	} name;
-	struct Address {					$\C{// nesting}$
+	struct Address {					§\C{// nesting}§
 		...
 	} address;
@@ -1374,11 +1373,11 @@
 \begin{cfa}
 Person p
-®p.®name; ®p.®address; ®p.®sex;			$\C{// access containing fields}$
+®p.®name; ®p.®address; ®p.®sex;			§\C{// access containing fields}§
 \end{cfa}
 which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
 \begin{cfa}
 struct Ticket { ... } t;
-®p.name®.first; ®p.address®.street;		$\C{// access nested fields}$
-®t.®departure; ®t.®cost;				$\C{// access multiple aggregate}$
+®p.name®.first; ®p.address®.street;		§\C{// access nested fields}§
+®t.®departure; ®t.®cost;				§\C{// access multiple aggregate}§
 \end{cfa}
 Repeated aggregate qualification is tedious and makes code difficult to read.
@@ -1389,7 +1388,7 @@
 \begin{cfa}
 struct S {
-	struct $\R{\LstCommentStyle{/* unnamed */}}$  { int g,  h; } __attribute__(( aligned(64) ));
+	struct §\R{\LstCommentStyle{/* unnamed */}}§  { int g,  h; } __attribute__(( aligned(64) ));
 	int tag;
-	union $\R{\LstCommentStyle{/* unnamed */}}$  {
+	union §\R{\LstCommentStyle{/* unnamed */}}§  {
 		struct { char c1,  c2; } __attribute__(( aligned(128) ));
 		struct { int i1,  i2; };
@@ -1405,6 +1404,6 @@
 struct S {
 	char ®c®;   int ®i®;   double ®d®;
-	void f( /* S * this */ ) {			$\C{// implicit ``this'' parameter}$
-		®c®;   ®i®;   ®d®;				$\C{// this->c; this->i; this->d;}$
+	void f( /* S * this */ ) {			§\C{// implicit ``this'' parameter}§
+		®c®;   ®i®;   ®d®;				§\C{// this->c; this->i; this->d;}§
 	}
 }
@@ -1414,12 +1413,12 @@
 \begin{cfa}
 struct T {
-	char ®m®;   int ®i®;   double ®n®;	$\C{// derived class variables}$
+	char ®m®;   int ®i®;   double ®n®;	§\C{// derived class variables}§
 };
 struct S : public T {
-	char ®c®;   int ®i®;   double ®d®;	$\C{// class variables}$
+	char ®c®;   int ®i®;   double ®d®;	§\C{// class variables}§
 	void g( double ®d®, T & t ) {
-		d;   ®t®.m;   ®t®.i;   ®t®.n;	$\C{// function parameter}$
-		c;   i;   ®this->®d;   ®S::®d;	$\C{// class S variables}$
-		m;   ®T::®i;   n;				$\C{// class T variables}$
+		d;   ®t®.m;   ®t®.i;   ®t®.n;	§\C{// function parameter}§
+		c;   i;   ®this->®d;   ®S::®d;	§\C{// class S variables}§
+		m;   ®T::®i;   n;				§\C{// class T variables}§
 	}
 };
@@ -1431,13 +1430,13 @@
 Hence, the qualified fields become variables with the side-effect that it is simpler to write, easier to read, and optimize field references in a block.
 \begin{cfa}
-void f( S & this ) ®with ( this )® {	$\C{// with statement}$
-	®c®;   ®i®;   ®d®;					$\C{// this.c, this.i, this.d}$
+void f( S & this ) ®with ( this )® {	§\C{// with statement}§
+	®c®;   ®i®;   ®d®;					§\C{// this.c, this.i, this.d}§
 }
 \end{cfa}
 with the generality of opening multiple aggregate-parameters:
 \begin{cfa}
-void g( S & s, T & t ) ®with ( s, t )® {$\C{// multiple aggregate parameters}$
-	c;   ®s.®i;   d;					$\C{// s.c, s.i, s.d}$
-	m;   ®t.®i;   n;					$\C{// t.m, t.i, t.n}$
+void g( S & s, T & t ) ®with ( s, t )® {§\C{// multiple aggregate parameters}§
+	c;   ®s.®i;   d;					§\C{// s.c, s.i, s.d}§
+	m;   ®t.®i;   n;					§\C{// t.m, t.i, t.n}§
 }
 \end{cfa}
@@ -1462,11 +1461,11 @@
 struct R { int ®i®; int j; double ®m®; } r, w;
 with ( r, q ) {
-	j + k;								$\C{// unambiguous, r.j + q.k}$
-	m = 5.0;							$\C{// unambiguous, q.m = 5.0}$
-	m = 1;								$\C{// unambiguous, r.m = 1}$
-	int a = m;							$\C{// unambiguous, a = r.i }$
-	double b = m;						$\C{// unambiguous, b = q.m}$
-	int c = r.i + q.i;					$\C{// disambiguate with qualification}$
-	(double)m;							$\C{// disambiguate with cast}$
+	j + k;								§\C{// unambiguous, r.j + q.k}§
+	m = 5.0;							§\C{// unambiguous, q.m = 5.0}§
+	m = 1;								§\C{// unambiguous, r.m = 1}§
+	int a = m;							§\C{// unambiguous, a = r.i }§
+	double b = m;						§\C{// unambiguous, b = q.m}§
+	int c = r.i + q.i;					§\C{// disambiguate with qualification}§
+	(double)m;							§\C{// disambiguate with cast}§
 }
 \end{cfa}
@@ -1476,7 +1475,7 @@
 \begin{cfa}
 with ( r ) {
-	i;									$\C{// unambiguous, r.i}$
+	i;									§\C{// unambiguous, r.i}§
 	with ( q ) {
-		i;								$\C{// unambiguous, q.i}$
+		i;								§\C{// unambiguous, q.i}§
 	}
 }
@@ -1485,6 +1484,6 @@
 A cast can also be used to disambiguate among overload variables in a ©with© \emph{expression}:
 \begin{cfa}
-with ( w ) { ... }						$\C{// ambiguous, same name and no context}$
-with ( (Q)w ) { ... }					$\C{// unambiguous, cast}$
+with ( w ) { ... }						§\C{// ambiguous, same name and no context}§
+with ( (Q)w ) { ... }					§\C{// unambiguous, cast}§
 \end{cfa}
 Because there is no left-side in the ©with© expression to implicitly disambiguate between the ©w© variables, it is necessary to explicitly disambiguate by casting ©w© to type ©Q© or ©R©.
@@ -1493,5 +1492,5 @@
 \begin{cfa}
 void f( S & s, char c ) with ( s ) {
-	®s.c = c;®  i = 3;  d = 5.5;		$\C{// initialize fields}$
+	®s.c = c;®  i = 3;  d = 5.5;		§\C{// initialize fields}§
 }
 \end{cfa}
@@ -1499,5 +1498,5 @@
 To solve this problem, parameters \emph{not} explicitly opened are treated like an initialized aggregate:
 \begin{cfa}
-struct Params {							$\C{// s explicitly opened so S \& s elided}$
+struct Params {							§\C{// s explicitly opened so S \& s elided}§
 	char c;
 } params;
@@ -1505,5 +1504,5 @@
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
-void f( S & s, char ®c® ) with ( s ) ®with( $\emph{\R{params}}$ )® { // syntax not allowed, illustration only
+void f( S & s, char ®c® ) with ( s ) ®with( §\emph{\R{params}}§ )® { // syntax not allowed, illustration only
 	s.c = ®c;®  i = 3;  d = 5.5;
 }
@@ -1538,14 +1537,14 @@
 
 \begin{cfa}
-exception_t E {}; $\C{// exception type}$
+exception_t E {}; §\C{// exception type}§
 void f(...) {
-	... throw E{}; ... $\C{// termination}$
-	... throwResume E{}; ... $\C{// resumption}$
+	... throw E{}; ... §\C{// termination}§
+	... throwResume E{}; ... §\C{// resumption}§
 }
 try {
 	f(...);
-} catch( E e ; $boolean-predicate$ ) {	$\C{// termination handler}$
+} catch( E e ; §boolean-predicate§ ) {	§\C{// termination handler}§
 	// recover and continue
-} catchResume( E e ; $boolean-predicate$ ) { $\C{// resumption handler}$
+} catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}§
 	// repair and return
 } finally {
@@ -1624,6 +1623,6 @@
 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
 \begin{cfa}
-int ®(*®f®())[®5®]® {...}; $\C{// definition}$
- ... ®(*®f®())[®3®]® += 1; $\C{// usage}$
+int ®(*®f®())[®5®]® {...}; §\C{// definition}§
+ ... ®(*®f®())[®3®]® += 1; §\C{// usage}§
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
@@ -1870,5 +1869,5 @@
 For example, \Index*{Algol68}~\cite{Algol68} infers pointer dereferencing to select the best meaning for each pointer usage
 \begin{cfa}
-p2 = p1 + x; $\C{// compiler infers *p2 = *p1 + x;}$
+p2 = p1 + x; §\C{// compiler infers *p2 = *p1 + x;}§
 \end{cfa}
 Algol68 infers the following dereferencing ©*p2 = *p1 + x©, because adding the arbitrary integer value in ©x© to the address of ©p1© and storing the resulting address into ©p2© is an unlikely operation.
@@ -1878,11 +1877,11 @@
 In C, objects of pointer type always manipulate the pointer object's address:
 \begin{cfa}
-p1 = p2; $\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}$
-p2 = p1 + x; $\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}$
+p1 = p2; §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§
+p2 = p1 + x; §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§
 \end{cfa}
 even though the assignment to ©p2© is likely incorrect, and the programmer probably meant:
 \begin{cfa}
-p1 = p2; $\C{// pointer address assignment}$
-®*®p2 = ®*®p1 + x; $\C{// pointed-to value assignment / operation}$
+p1 = p2; §\C{// pointer address assignment}§
+®*®p2 = ®*®p1 + x; §\C{// pointed-to value assignment / operation}§
 \end{cfa}
 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
@@ -1901,9 +1900,9 @@
 \begin{cfa}
 int x, y, ®&® r1, ®&® r2, ®&&® r3;
-®&®r1 = &x; $\C{// r1 points to x}$
-®&®r2 = &r1; $\C{// r2 points to x}$
-®&®r1 = &y; $\C{// r1 points to y}$
-®&&®r3 = ®&®&r2; $\C{// r3 points to r2}$
-r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); $\C{// implicit dereferencing}$
+®&®r1 = &x; §\C{// r1 points to x}§
+®&®r2 = &r1; §\C{// r2 points to x}§
+®&®r1 = &y; §\C{// r1 points to y}§
+®&&®r3 = ®&®&r2; §\C{// r3 points to r2}§
+r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); §\C{// implicit dereferencing}§
 \end{cfa}
 Except for auto-dereferencing by the compiler, this reference example is the same as the previous pointer example.
@@ -1920,9 +1919,9 @@
 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
 \begin{cfa}
-(&®*®)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
+(&®*®)r1 = &x; §\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}§
 \end{cfa}
 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
 \begin{cfa}
-(&(&®*®)®*®)r3 = &(&®*®)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
+(&(&®*®)®*®)r3 = &(&®*®)r2; §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§
 \end{cfa}
 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
@@ -1932,11 +1931,11 @@
 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
 		 &r1 = x,    &&r2 = r1,   &&&r3 = r2;
-***p3 = 3; $\C{// change x}$
-r3 = 3; $\C{// change x, ***r3}$
-**p3 = ...; $\C{// change p1}$
-&r3 = ...; $\C{// change r1, (\&*)**r3, 1 cancellation}$
-*p3 = ...; $\C{// change p2}$
-&&r3 = ...; $\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}$
-&&&r3 = p3; $\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}$
+***p3 = 3; §\C{// change x}§
+r3 = 3; §\C{// change x, ***r3}§
+**p3 = ...; §\C{// change p1}§
+&r3 = ...; §\C{// change r1, (\&*)**r3, 1 cancellation}§
+*p3 = ...; §\C{// change p2}§
+&&r3 = ...; §\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}§
+&&&r3 = p3; §\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}§
 \end{cfa}
 Furthermore, both types are equally performant, as the same amount of dereferencing occurs for both types.
@@ -1945,17 +1944,17 @@
 As for a pointer type, a reference type may have qualifiers:
 \begin{cfa}
-const int cx = 5; $\C{// cannot change cx;}$
-const int & cr = cx; $\C{// cannot change what cr points to}$
-®&®cr = &cx; $\C{// can change cr}$
-cr = 7; $\C{// error, cannot change cx}$
-int & const rc = x; $\C{// must be initialized}$
-®&®rc = &x; $\C{// error, cannot change rc}$
-const int & const crc = cx; $\C{// must be initialized}$
-crc = 7; $\C{// error, cannot change cx}$
-®&®crc = &cx; $\C{// error, cannot change crc}$
+const int cx = 5; §\C{// cannot change cx;}§
+const int & cr = cx; §\C{// cannot change what cr points to}§
+®&®cr = &cx; §\C{// can change cr}§
+cr = 7; §\C{// error, cannot change cx}§
+int & const rc = x; §\C{// must be initialized}§
+®&®rc = &x; §\C{// error, cannot change rc}§
+const int & const crc = cx; §\C{// must be initialized}§
+crc = 7; §\C{// error, cannot change cx}§
+®&®crc = &cx; §\C{// error, cannot change crc}§
 \end{cfa}
 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
 \begin{cfa}
-int & const cr = *0; $\C{// where 0 is the int * zero}$
+int & const cr = *0; §\C{// where 0 is the int * zero}§
 \end{cfa}
 Note, constant reference-types do not prevent \Index{addressing errors} because of explicit storage-management:
@@ -1964,5 +1963,5 @@
 cr = 5;
 free( &cr );
-cr = 7; $\C{// unsound pointer dereference}$
+cr = 7; §\C{// unsound pointer dereference}§
 \end{cfa}
 
@@ -1972,5 +1971,5 @@
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{Cy}}	& \multicolumn{1}{c}{\textbf{\CFA}}	\\
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}}	& \multicolumn{1}{c}{\textbf{\CFA}}	\\
 \begin{cfa}
 const int * ®const® * ®const® ccp;
@@ -1988,10 +1987,10 @@
 Finally, like pointers, references are usable and composable with other type operators and generators.
 \begin{cfa}
-int w, x, y, z, & ar[3] = { x, y, z }; $\C{// initialize array of references}$
-&ar[1] = &w; $\C{// change reference array element}$
-typeof( ar[1] ) p; $\C{// (gcc) is int, \ie the type of referenced object}$
-typeof( &ar[1] ) q; $\C{// (gcc) is int \&, \ie the type of reference}$
-sizeof( ar[1] ) == sizeof( int ); $\C{// is true, \ie the size of referenced object}$
-sizeof( &ar[1] ) == sizeof( int *) $\C{// is true, \ie the size of a reference}$
+int w, x, y, z, & ar[3] = { x, y, z }; §\C{// initialize array of references}§
+&ar[1] = &w; §\C{// change reference array element}§
+typeof( ar[1] ) p; §\C{// (gcc) is int, \ie the type of referenced object}§
+typeof( &ar[1] ) q; §\C{// (gcc) is int \&, \ie the type of reference}§
+sizeof( ar[1] ) == sizeof( int ); §\C{// is true, \ie the size of referenced object}§
+sizeof( &ar[1] ) == sizeof( int *) §\C{// is true, \ie the size of a reference}§
 \end{cfa}
 
@@ -2010,7 +2009,7 @@
 Therefore, for pointer/reference initialization, the initializing value must be an address not a value.
 \begin{cfa}
-int * p = &x; $\C{// assign address of x}$
-®int * p = x;® $\C{// assign value of x}$
-int & r = x; $\C{// must have address of x}$
+int * p = &x;				§\C{// assign address of x}§
+®int * p = x;®				§\C{// assign value of x}§
+int & r = x;				§\C{// must have address of x}§
 \end{cfa}
 Like the previous example with C pointer-arithmetic, it is unlikely assigning the value of ©x© into a pointer is meaningful (again, a warning is usually given).
@@ -2021,6 +2020,6 @@
 Similarly, when a reference type is used for a parameter/return type, the call-site argument does not require a reference operator for the same reason.
 \begin{cfa}
-int & f( int & r ); $\C{// reference parameter and return}$
-z = f( x ) + f( y ); $\C{// reference operator added, temporaries needed for call results}$
+int & f( int & r );			§\C{// reference parameter and return}§
+z = f( x ) + f( y );		§\C{// reference operator added, temporaries needed for call results}§
 \end{cfa}
 Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©r© can be locally reassigned within ©f©.
@@ -2049,6 +2048,6 @@
 void f( int & r );
 void g( int * p );
-f( 3 );			  g( ®&®3 ); $\C{// compiler implicit generates temporaries}$
-f( x + y );		g( ®&®(x + y) ); $\C{// compiler implicit generates temporaries}$
+f( 3 );			  g( ®&®3 ); §\C{// compiler implicit generates temporaries}§
+f( x + y );		g( ®&®(x + y) ); §\C{// compiler implicit generates temporaries}§
 \end{cfa}
 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
@@ -2061,19 +2060,19 @@
 \begin{cfa}
 void f( int i );
-void (* fp)( int ); $\C{// routine pointer}$
-fp = f; $\C{// reference initialization}$
-fp = &f; $\C{// pointer initialization}$
-fp = *f; $\C{// reference initialization}$
-fp(3); $\C{// reference invocation}$
-(*fp)(3); $\C{// pointer invocation}$
+void (* fp)( int );			§\C{// routine pointer}§
+fp = f;						§\C{// reference initialization}§
+fp = &f;					§\C{// pointer initialization}§
+fp = *f;					§\C{// reference initialization}§
+fp(3);						§\C{// reference invocation}§
+(*fp)(3);					§\C{// pointer invocation}§
 \end{cfa}
 While C's treatment of routine objects has similarity to inferring a reference type in initialization contexts, the examples are assignment not initialization, and all possible forms of assignment are possible (©f©, ©&f©, ©*f©) without regard for type.
 Instead, a routine object should be referenced by a ©const© reference:
 \begin{cfa}
-®const® void (®&® fr)( int ) = f; $\C{// routine reference}$
-fr = ... $\C{// error, cannot change code}$
-&fr = ...; $\C{// changing routine reference}$
-fr( 3 ); $\C{// reference call to f}$
-(*fr)(3); $\C{// error, incorrect type}$
+®const® void (®&® fr)( int ) = f; §\C{// routine reference}§
+fr = ...;					§\C{// error, cannot change code}§
+&fr = ...;					§\C{// changing routine reference}§
+fr( 3 );					§\C{// reference call to f}§
+(*fr)(3);					§\C{// error, incorrect type}§
 \end{cfa}
 because the value of the routine object is a routine literal, \ie the routine code is normally immutable during execution.\footnote{
@@ -2097,9 +2096,9 @@
 int x, * px, ** ppx, *** pppx, **** ppppx;
 int & rx = x, && rrx = rx, &&& rrrx = rrx ;
-x = rrrx; $\C[2.0in]{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}$
-px = &rrrx; $\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}$
-ppx = &&rrrx; $\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}$
-pppx = &&&rrrx; $\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}$
-ppppx = &&&&rrrx; $\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}$
+x = rrrx;					§\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§
+px = &rrrx;					§\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}§
+ppx = &&rrrx;				§\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}§
+pppx = &&&rrrx;				§\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}§
+ppppx = &&&&rrrx;			§\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}§
 \end{cfa}
 The following example shows the second rule applied to different \Index{lvalue} contexts:
@@ -2107,8 +2106,8 @@
 int x, * px, ** ppx, *** pppx;
 int & rx = x, && rrx = rx, &&& rrrx = rrx ;
-rrrx = 2; $\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}$
-&rrrx = px; $\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}$
-&&rrrx = ppx; $\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}$
-&&&rrrx = pppx; $\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}\CRT$
+rrrx = 2;					§\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§
+&rrrx = px;					§\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}§
+&&rrrx = ppx;				§\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}§
+&&&rrrx = pppx;				§\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}§
 \end{cfa}
 
@@ -2123,5 +2122,5 @@
 \begin{cfa}
 int x;
-x + 1; $\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}$
+x + 1;						§\C{// lvalue variable (int) converts to rvalue for expression}§
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped.
@@ -2133,5 +2132,5 @@
 \begin{cfa}
 int x, &r = x, f( int p );
-x = ®r® + f( ®r® ); $\C{// lvalue reference converts to rvalue}$
+x = ®r® + f( ®r® );			§\C{// lvalue reference converts to rvalue}§
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
@@ -2140,6 +2139,6 @@
 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]{lvalue-type cv1 T} converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
-int x, &r = ®x®, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
-f( ®x® ); $\C{// lvalue variable (int) convert to reference (int \&)}\CRT$
+int x, &r = ®x®, f( int & p ); §\C{// lvalue variable (int) convert to reference (int \&)}§
+f( ®x® );					§\C{// lvalue variable (int) convert to reference (int \&)}§
 \end{cfa}
 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
@@ -2151,6 +2150,6 @@
 \begin{cfa}
 int x, & f( int & p );
-f( ®x + 3® );	$\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
-®&f®(...) = &x;	$\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
+f( ®x + 3® );				§\C{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}§
+®&f®(...) = &x;				§\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}§
 \end{cfa}
 In both case, modifications to the temporary are inaccessible (\Index{warning}).
@@ -2319,4 +2318,380 @@
 
 
+\section{\lstinline{string} Type}
+\label{s:stringType}
+
+The \CFA \Indexc{string} type is for manipulation of dynamically-size character-strings versus C \Indexc{char *} type for manipulation of statically-size null-terminated character-strings.
+That is, the amount of storage for a \CFA string changes dynamically at runtime to fit the string size, whereas the amount of storage for a C string is fixed at compile time.
+Hence, a ©string© declaration does not specify a maximum length;
+as a string dynamically grows and shrinks in size, so does its underlying storage.
+In contrast, a C string also dynamically grows and shrinks is size, but its underlying storage is fixed.
+The maximum storage for a \CFA ©string© value is ©size_t© characters, which is $2^{32}$ or $2^{64}$ respectively.
+A \CFA string manages its length separately from the string, so there is no null (©'\0'©) terminating value at the end of a string value.
+Hence, a \CFA string cannot be passed to a C string manipulation routine, such as ©strcat©.
+Like C strings, the characters in a ©string© are numbered starting from 0.
+
+The following operations have been defined to manipulate an instance of type ©string©.
+The discussion assumes the following declarations and assignment statements are executed.
+\begin{cfa}
+#include ®<string.hfa>®
+®string® s, peter, digit, alpha, punctuation, ifstmt;
+int i;
+peter  = "PETER";
+digit  = "0123456789";
+punctuation = "().,";
+ifstmt = "IF (A > B) {";
+\end{cfa}
+Note, the include file \Indexc{string.hfa} to access type ©string©.
+
+
+\subsection{Implicit String Conversions}
+
+The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including signness and different sizes, implicitly convert to type ©string©.
+\VRef[Figure]{f:ImplicitStringConversions} shows examples of implicit conversion between C strings, integral, floating-point and complex types to ©string©
+The implicit conversions can be specified explicitly, as in:
+\begin{cfa}
+s = string( "abc" );		// converts char * to string
+s = string( 5 );			// converts int to string
+s = string( 5.5 );			// converts double to string
+\end{cfa}
+Conversions from ©string© to ©char *© are supported but with restrictions.
+Explicit As well, when a string is converted to a ©char *©, the storage for the ©char *© is created by the conversion operation, which must be subsequently deleted:
+\begin{cfa}
+string x = "abc";
+char *p = x;				// convert from string to char *
+...
+delete p;					// free storage created for p
+\end{cfa}
+
+\begin{figure}
+\begin{tabular}{@{}l@{\hspace{15pt}}|@{\hspace{15pt}}l@{}}
+\begin{cfa}
+//	string s = 5;					sout | s;
+	string s;
+	// conversion of char and char * to string
+	s = 'x';						§\CD{sout | s;}§
+	s = "abc";						§\CD{sout | s;}§
+	char cs[5] = "abc";
+	s = cs;							§\CD{sout | s;}§
+	// conversion of integral, floating-point, and complex to string
+	s = 45hh;						§\CD{sout | s;}§
+	s = 45h;						§\CD{sout | s;}§
+	s = -(ssize_t)MAX - 1;			§\CD{sout | s;}§
+	s = (size_t)MAX;				§\CD{sout | s;}§
+	s = 5.5;						§\CD{sout | s;}§
+	s = 5.5L;						§\CD{sout | s;}§
+	s = 5.5+3.4i;					§\CD{sout | s;}§
+	s = 5.5L+3.4Li;					§\CD{sout | s;}§
+	// safe conversion from string to char *
+	strncpy( cs, s, sizeof(cs) );	§\CD{sout | cs;}§
+	char * cp = s;					§\CD{sout | cp; // ownership}§
+	delete( cp );
+	cp = s + ' ' + s;				§\CD{sout | cp; // ownership}§
+	delete( cp );
+\end{cfa}
+&
+\begin{cfa}
+
+
+
+x
+abc
+
+abc
+
+45
+45
+-9223372036854775808
+18446744073709551615
+5.5
+5.5
+5.5+3.4i
+5.5+3.4i
+
+5.5+
+5.5+3.4i
+
+5.5+3.4i 5.5+3.4i
+
+\end{cfa}
+\end{tabular}
+\caption{Implicit String Conversions}
+\label{f:ImplicitStringConversions}
+\end{figure}
+
+
+\subsection{Comparison Operators}
+
+The binary relational and equality operators ©<©, ©<=©, ©>©, ©>=©, ©==©, ©!=© compare ©string© using lexicographical ordering, where longer strings are greater than shorter strings.
+
+
+\subsection{Concatenation}
+
+The binary operator ©+© concatenates two strings.
+\begin{cfa}
+s = peter + digit;					§\C{// s is assigned "PETER0123456789"}§
+s += peter;							§\C{// s is assigned "PETER0123456789PETER"}§
+\end{cfa}
+There is also an assignment form ©+=©.
+
+
+\subsection{Repetition}
+
+The binary operator \Indexc{*} returns a string that is the string repeated ©n© times.
+If ©n = 0©, a zero length string, ©""© is returned.
+\begin{cfa}
+s = (peter + ' ') * 3;				§\C{// s is assigned "PETER PETER PETER"}§
+\end{cfa}
+There is also an assignment form ©*=©.
+
+
+\subsection{Length}
+
+The ©length© operation
+\begin{cfa}
+int length()
+\end{cfa}
+returns the length of a string variable.
+\begin{cfa}
+i = peter.length();			§\C{// i is assigned the value 5}§
+\end{cfa}
+
+
+\subsection{Substring}
+The substring operation:
+\begin{cfa}
+string operator () (int start, int lnth);
+\end{cfa}
+performs a substring operation that returns the string starting at a specified position (©start©) in the current string, and having the specified length (©lnth©).
+A negative starting position is a specification from the right end of the string.
+A negative length means that characters are selected in the opposite (right to left) direction from the starting position.
+If the substring request extends beyond the beginning or end of the string, it is clipped (shortened) to the bounds of the string.
+If the substring request is completely outside of the original string, a null string located at the end of the original string is returned.
+\begin{cfa}
+s = peter( 2, 3 );			§\C{// s is assigned "ETE"}§
+s = peter( 4, -3 );			§\C{// s is assigned "ETE", length is opposite direction}§
+s = peter( 2, 8 );			§\C{// s is assigned "ETER", length is clipped to 4}§
+s = peter( 0, -1 );			§\C{// s is assigned "", beyond string so clipped to null}§
+s = peter(-1, -1 );			§\C{// s is assigned "R", start and length are negative}§
+\end{cfa}
+The substring operation can also appear on the left hand side of the assignment operator.
+The substring is replaced by the value on the right hand side of the assignment.
+The length of the right-hand-side value may be shorter, the same length, or longer than the length of the substring that is selected on the left hand side of the assignment.
+\begin{cfa}[mathescape=false]
+digit( 3, 3 ) = "";   		§\C{// digit is assigned "0156789"}§
+digit( 4, 3 ) = "xyz";		§\C{// digit is assigned "015xyz9"}§
+digit( 7, 0 ) = "***";		§\C{// digit is assigned "015xyz***9"}§
+digit(-4, 3 ) = "$$$";		§\C{// digit is assigned "015xyz\$\$\$9"}§
+\end{cfa}
+A substring is treated as a pointer into the base (substringed) string rather than creating a copy of the subtext.
+As with all pointers, if the item they are pointing at is changed, then the pointer is referring to the changed item.
+Pointers to the result value of a substring operation are defined to always start at the same location in their base string as long as that starting location exists, independent of changes to themselves or the base string.
+However, if the base string value changes, this may affect the values of one or more of the substrings to that base string.
+If the base string value shortens so that its end is before the starting location of a substring, resulting in the substring starting location disappearing, the substring becomes a null string located at the end of the base string.
+
+The following example illustrates passing the results of substring operations by reference and by value to a subprogram.
+Notice the side-effects to other reference parameters as one is modified.
+\begin{cfa}
+main() {
+	string x = "xxxxxxxxxxxxx";
+	test( x, x(1,3), x(3,3), x(5,5), x(9,5), x(9,5) );
+}
+
+// x, a, b, c, & d are substring results passed by reference
+// e is a substring result passed by value
+void test(string &x, string &a, string &b, string &c, string &d, string e) {
+							§\C{//   x			  	  a	 	  b	 	  c		  d		  e}§
+	a( 1, 2 ) = "aaa";		§\C{// aaaxxxxxxxxxxx	aaax	axx		xxxxx	xxxxx	xxxxx}§
+	b( 2, 12 ) = "bbb";		§\C{// aaabbbxxxxxxxxx	aaab	abbb	bbxxx	xxxxx	xxxxx}§
+	c( 4, 5 ) = "ccc";		§\C{// aaabbbxcccxxxxxx	aaab	abbb	bbxccc	ccxxx	xxxxx}§
+	c = "yyy";				§\C{// aaabyyyxxxxxx	aaab	abyy	yyy		xxxxx	xxxxx}§
+	d( 1, 3 ) = "ddd";		§\C{// aaabyyyxdddxx	aaab	abyy	yyy		dddxx	xxxxx}§
+	e( 1, 3 ) = "eee";		§\C{// aaabyyyxdddxx	aaab	abyy	yyy		dddxx	eeexx}§
+	x = e;					§\C{// eeexx			eeex	exx		x				eeexx}§
+}
+\end{cfa}
+
+There is an assignment form of substring in which only the starting position is specified and the length is assumed to be the remainder of the string.
+\begin{cfa}
+string operator () (int start);
+\end{cfa}
+For example:
+\begin{cfa}
+s = peter( 2 );				§\C{// s is assigned "ETER"}§
+peter( 2 ) = "IPER";		§\C{// peter is assigned "PIPER"}§
+\end{cfa}
+It is also possible to substring using a string as the index for selecting the substring portion of the string.
+\begin{cfa}
+string operator () (const string &index);
+\end{cfa}
+For example:
+\begin{cfa}[mathescape=false]
+digit( "xyz$$$" ) = "678"; 	§\C{// digit is assigned "0156789"}§
+digit( "234") = "***";		§\C{// digit is assigned "0156789***"}§
+\end{cfa}
+%$
+
+
+\subsection{Searching}
+
+The ©index© operation
+\begin{cfa}
+int index( const string &key, int start = 1, occurrence occ = first );
+\end{cfa}
+returns the position of the first or last occurrence of the ©key© (depending on the occurrence indicator ©occ© that is either ©first© or ©last©) in the current string starting the search at position ©start©.
+If the ©key© does not appear in the current string, the length of the current string plus one is returned.
+%If the ©key© has zero length, the value 1 is returned regardless of what the current string contains.
+A negative starting position is a specification from the right end of the string.
+\begin{cfa}
+i = digit.index( "567" );			§\C{// i is assigned 3}§
+i = digit.index( "567", 7 );		§\C{// i is assigned 11}§
+i = digit.index( "567", -1, last );	§\C{// i is assigned 3}§
+i = peter.index( "E", 5, last );	§\C{// i is assigned 4}§
+\end{cfa}
+
+The next two string operations test a string to see if it is or is not composed completely of a particular class of characters.
+For example, are the characters of a string all alphabetic or all numeric?
+Use of these operations involves a two step operation.
+First, it is necessary to create an instance of type ©strmask© and initialize it to a string containing the characters of the particular character class, as in:
+\begin{cfa}
+strmask digitmask = digit;
+strmask alphamask = string( "abcdefghijklmnopqrstuvwxyz" );
+\end{cfa}
+Second, the character mask is used in the functions ©include© and ©exclude© to check a string for compliance of its characters with the characters indicated by the mask.
+
+The ©include© operation
+\begin{cfa}
+int include( const strmask &, int = 1, occurrence occ = first );
+\end{cfa}
+returns the position of the first or last character (depending on the occurrence indicator, which is either ©first© or ©last©) in the current string that does not appear in the ©mask© starting the search at position ©start©;
+hence it skips over characters in the current string that are included (in) the ©mask©.
+The characters in the current string do not have to be in the same order as the ©mask©.
+If all the characters in the current string appear in the ©mask©, the length of the current string plus one is returned, regardless of which occurrence is being searched for.
+A negative starting position is a specification from the right end of the string.
+\begin{cfa}
+i = peter.include( digitmask );	§\C{// i is assigned 1}§
+i = peter.include( alphamask );	§\C{// i is assigned 6}§
+\end{cfa}
+
+The ©exclude© operation
+\begin{cfa}
+int exclude( string &mask, int start = 1, occurrence occ = first )
+\end{cfa}
+returns the position of the first or last character (depending on the occurrence indicator, which is either ©first© or ©last©) in the current string that does appear in the ©mask© string starting the search at position ©start©;
+hence it skips over characters in the current string that are excluded from (not in) in the ©mask© string.
+The characters in the current string do not have to be in the same order as the ©mask© string.
+If all the characters in the current string do NOT appear in the ©mask© string, the length of the current string plus one is returned, regardless of which occurrence is being searched for.
+A negative starting position is a specification from the right end of the string.
+\begin{cfa}
+i = peter.exclude( digitmask );		§\C{// i is assigned 6}§
+i = ifstmt.exclude( strmask( punctuation ) ); §\C{// i is assigned 4}§
+\end{cfa}
+
+The ©includeStr© operation:
+\begin{cfa}
+string includeStr( strmask &mask, int start = 1, occurrence occ = first )
+\end{cfa}
+returns the longest substring of leading or trailing characters (depending on the occurrence indicator, which is either ©first© or ©last©) of the current string that ARE included in the ©mask© string starting the search at position ©start©.
+A negative starting position is a specification from the right end of the string.
+\begin{cfa}
+s = peter.includeStr( alphamask );	§\C{// s is assigned "PETER"}§
+s = ifstmt.includeStr( alphamask );	§\C{// s is assigned "IF"}§
+s = peter.includeStr( digitmask );	§\C{// s is assigned ""}§
+\end{cfa}
+
+The ©excludeStr© operation:
+\begin{cfa}
+string excludeStr( strmask &mask, int start = 1, occurrence = first )
+\end{cfa}
+returns the longest substring of leading or trailing characters (depending on the occurrence indicator, which is either ©first© or ©last©) of the current string that are excluded (NOT) in the ©mask© string starting the search at position ©start©.
+A negative starting position is a specification from the right end of the string.
+\begin{cfa}
+s = peter.excludeStr( digitmask);	§\C{// s is assigned "PETER"}§
+s = ifstmt.excludeStr( strmask( punctuation ) ); §\C{// s is assigned "IF "}§
+s = peter.excludeStr( alphamask);	§\C{// s is assigned ""}§
+\end{cfa}
+
+
+\subsection{Miscellaneous}
+
+The ©trim© operation
+\begin{cfa}
+string trim( string &mask, occurrence occ = first )
+\end{cfa}
+returns a string in that is the longest substring of leading or trailing characters (depending on the occurrence indicator, which is either ©first© or ©last©) which ARE included in the ©mask© are removed.
+\begin{cfa}
+// remove leading blanks
+s = string( "   ABC" ).trim( " " );			§\C{// s is assigned "ABC",}§
+// remove trailing blanks
+s = string( "ABC   " ).trim( " ", last );	§\C{// s is assigned "ABC",}§
+\end{cfa}
+
+The ©translate© operation
+\begin{cfa}
+string translate( string &from, string &to )
+\end{cfa}
+returns a string that is the same length as the original string in which all occurrences of the characters that appear in the ©from© string have been translated into their corresponding character in the ©to© string.
+Translation is done on a character by character basis between the ©from© and ©to© strings; hence these two strings must be the same length.
+If a character in the original string does not appear in the ©from© string, then it simply appears as is in the resulting string.
+\begin{cfa}
+// upper to lower case
+peter = peter.translate( "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz" );
+			// peter is assigned "peter"
+s = ifstmt.translate( "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz" );
+			// ifstmt is assigned "if (a > b) {"
+// lower to upper case
+peter = peter.translate( "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ" );
+			// peter is assigned "PETER"
+\end{cfa}
+
+The ©replace© operation
+\begin{cfa}
+string replace( string &from, string &to )
+\end{cfa}
+returns a string in which all occurrences of the ©from© string in the current string have been replaced by the ©to© string.
+\begin{cfa}
+s = peter.replace( "E", "XX" );	§\C{// s is assigned "PXXTXXR"}§
+\end{cfa}
+The replacement is done left-to-right.
+When an instance of the ©from© string is found and changed to the ©to© string, it is NOT examined again for further replacement.
+
+
+\section{Returning N+1 on Failure}
+
+Any of the string search routines can fail at some point during the search.
+When this happens it is necessary to return indicating the failure.
+Many string types in other languages use some special value to indicate the failure.
+This value is often 0 or -1 (PL/I returns 0).
+This section argues that a value of N+1, where N is the length of the base string in the search, is a more useful value to return.
+The index-of function in APL returns N+1.
+These are the boundary situations and are often overlooked when designing a string type.
+
+The situation that can be optimized by returning N+1 is when a search is performed to find the starting location for a substring operation.
+For example, in a program that is extracting words from a text file, it is necessary to scan from left to right over whitespace until the first alphabetic character is found.
+\begin{cfa}
+line = line( line.exclude( alpha ) );
+\end{cfa}
+If a text line contains all whitespaces, the exclude operation fails to find an alphabetic character.
+If ©exclude© returns 0 or -1, the result of the substring operation is unclear.
+Most string types generate an error, or clip the starting value to 1, resulting in the entire whitespace string being selected.
+If ©exclude© returns N+1, the starting position for the substring operation is beyond the end of the string leaving a null string.
+
+The same situation occurs when scanning off a word.
+\begin{cfa}
+start = line.include(alpha);
+word = line(1, start - 1);
+\end{cfa}
+If the entire line is composed of a word, the include operation will  fail to find a non-alphabetic character.
+In general, returning 0 or -1 is not an appropriate starting position for the substring, which must substring off the word leaving a null string.
+However, returning N+1 will substring off the word leaving a null string.
+
+
+\subsection{Input/Output Operators}
+
+Both the \CC operators ©<<© and ©>>© are defined on type ©string©.
+However, input of a string value is different from input of a ©char *© value.
+When a string value is read, \emph{all} input characters from the current point in the input stream to either the end of line (©'\n'©) or the end of file are read.
+
+
 \section{Enumeration}
 
@@ -2332,8 +2707,8 @@
 Hence, enums may be overloaded with variable, enum, and function names.
 \begin{cfa}
-int Foo;			$\C{// type/variable separate namespaces}$
+int Foo;			§\C{// type/variable separate namespaces}§
 enum Foo { Bar };
-enum Goo { Bar };	$\C[1.75in]{// overload Foo.Bar}$
-double Bar;			$\C{// overload Foo.Bar, Goo.Bar}\CRT$
+enum Goo { Bar };	§\C[1.75in]{// overload Foo.Bar}§
+double Bar;			§\C{// overload Foo.Bar, Goo.Bar}\CRT§
 \end{cfa}
 An anonymous enumeration injects enums with specific values into a scope.
@@ -2408,15 +2783,15 @@
 The following examples illustrate the difference between the enumeration type and the type of its enums.
 \begin{cfa}
-Math m = PI;	$\C[1.5in]{// allowed}$
-double d = PI;	$\C{// allowed, conversion to base type}$
-m = E;			$\C{// allowed}$
-m = Alph;		$\C{// {\color{red}disallowed}}$
-m = 3.141597;	$\C{// {\color{red}disallowed}}$
-d = m;			$\C{// allowed}$
-d = Alph;		$\C{// {\color{red}disallowed}}$
-Letter l = A;	$\C{// allowed}$
-Greek g = Alph;	$\C{// allowed}$
-l = Alph;		$\C{// allowed, conversion to base type}$
-g = A;			$\C{// {\color{red}disallowed}}\CRT$
+Math m = PI;	§\C[1.5in]{// allowed}§
+double d = PI;	§\C{// allowed, conversion to base type}§
+m = E;			§\C{// allowed}§
+m = Alph;		§\C{// {\color{red}disallowed}}§
+m = 3.141597;	§\C{// {\color{red}disallowed}}§
+d = m;			§\C{// allowed}§
+d = Alph;		§\C{// {\color{red}disallowed}}§
+Letter l = A;	§\C{// allowed}§
+Greek g = Alph;	§\C{// allowed}§
+l = Alph;		§\C{// allowed, conversion to base type}§
+g = A;			§\C{// {\color{red}disallowed}}\CRT§
 \end{cfa}
 
@@ -2508,5 +2883,5 @@
 \begin{cfa}
 ®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
-	$\emph{routine body}$
+	§\emph{routine body}§
 }
 \end{cfa}
@@ -2519,11 +2894,11 @@
 Declaration qualifiers can only appear at the start of a routine definition, \eg:
 \begin{cfa}
-®extern® [ int x ] g( int y ) {$\,$}
+®extern® [ int x ] g( int y ) {§\,§}
 \end{cfa}
 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
 in both cases the type is assumed to be void as opposed to old style C defaults of int return type and unknown parameter types, respectively, as in:
 \begin{cfa}
-[$\,$] g(); $\C{// no input or output parameters}$
-[ void ] g( void ); $\C{// no input or output parameters}$
+[§\,§] g(); §\C{// no input or output parameters}§
+[ void ] g( void ); §\C{// no input or output parameters}§
 \end{cfa}
 
@@ -2543,5 +2918,5 @@
 \begin{cfa}
 typedef int foo;
-int f( int (* foo) ); $\C{// foo is redefined as a parameter name}$
+int f( int (* foo) ); §\C{// foo is redefined as a parameter name}§
 \end{cfa}
 The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo.
@@ -2551,12 +2926,12 @@
 C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
 \begin{cfa}
-[ int ] f( * int, int * ); $\C{// returns an integer, accepts 2 pointers to integers}$
-[ * int, int * ] f( int ); $\C{// returns 2 pointers to integers, accepts an integer}$
+[ int ] f( * int, int * ); §\C{// returns an integer, accepts 2 pointers to integers}§
+[ * int, int * ] f( int ); §\C{// returns 2 pointers to integers, accepts an integer}§
 \end{cfa}
 The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate C-style declaration-syntax, as in:
 \begin{cfa}
 #define ptoa( n, d ) int (*n)[ d ]
-int f( ptoa( p, 5 ) ) ... $\C{// expands to int f( int (*p)[ 5 ] )}$
-[ int ] f( ptoa( p, 5 ) ) ... $\C{// expands to [ int ] f( int (*p)[ 5 ] )}$
+int f( ptoa( p, 5 ) ) ... §\C{// expands to int f( int (*p)[ 5 ] )}§
+[ int ] f( ptoa( p, 5 ) ) ... §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
 \end{cfa}
 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
@@ -2580,5 +2955,5 @@
 	int z;
 	... x = 0; ... y = z; ...
-	®return;® $\C{// implicitly return x, y}$
+	®return;® §\C{// implicitly return x, y}§
 }
 \end{cfa}
@@ -2590,5 +2965,5 @@
 [ int x, int y ] f() {
 	...
-} $\C{// implicitly return x, y}$
+} §\C{// implicitly return x, y}§
 \end{cfa}
 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered.
@@ -2599,9 +2974,9 @@
 [ int x, int y ] f( int, x, int y ) {
 	...
-} $\C{// implicitly return x, y}$
+} §\C{// implicitly return x, y}§
 \end{cfa}
 This notation allows the compiler to eliminate temporary variables in nested routine calls.
 \begin{cfa}
-[ int x, int y ] f( int, x, int y ); $\C{// prototype declaration}$
+[ int x, int y ] f( int, x, int y ); §\C{// prototype declaration}§
 int a, b;
 [a, b] = f( f( f( a, b ) ) );
@@ -2617,8 +2992,8 @@
 as well, parameter names are optional, \eg:
 \begin{cfa}
-[ int x ] f (); $\C{// returning int with no parameters}$
-[ * int ] g (int y); $\C{// returning pointer to int with int parameter}$
-[ ] h ( int, char ); $\C{// returning no result with int and char parameters}$
-[ * int, int ] j ( int ); $\C{// returning pointer to int and int, with int parameter}$
+[ int x ] f (); §\C{// returning int with no parameters}§
+[ * int ] g (int y); §\C{// returning pointer to int with int parameter}§
+[ ] h ( int, char ); §\C{// returning no result with int and char parameters}§
+[ * int, int ] j ( int ); §\C{// returning pointer to int and int, with int parameter}§
 \end{cfa}
 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
@@ -2626,5 +3001,5 @@
 \begin{cfa}
 C :		const double bar1(), bar2( int ), bar3( double );
-$\CFA$:	[const double] foo(), foo( int ), foo( double ) { return 3.0; }
+§\CFA§:	[const double] foo(), foo( int ), foo( double ) { return 3.0; }
 \end{cfa}
 \CFA allows the last routine in the list to define its body.
@@ -2641,13 +3016,13 @@
 The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
 \begin{cfa}
-* [ int x ] () fp; $\C[2.25in]{// pointer to routine returning int with no parameters}$
-* [ * int ] (int y) gp; $\C{// pointer to routine returning pointer to int with int parameter}$
-* [ ] (int,char) hp; $\C{// pointer to routine returning no result with int and char parameters}$
-* [ * int,int ] ( int ) jp; $\C{// pointer to routine returning pointer to int and int, with int parameter}\CRT$
+* [ int x ] () fp; §\C[2.25in]{// pointer to routine returning int with no parameters}§
+* [ * int ] (int y) gp; §\C{// pointer to routine returning pointer to int with int parameter}§
+* [ ] (int,char) hp; §\C{// pointer to routine returning no result with int and char parameters}§
+* [ * int,int ] ( int ) jp; §\C{// pointer to routine returning pointer to int and int, with int parameter}\CRT§
 \end{cfa}
 While parameter names are optional, \emph{a routine name cannot be specified};
 for example, the following is incorrect:
 \begin{cfa}
-* [ int x ] f () fp; $\C{// routine name "f" is not allowed}$
+* [ int x ] f () fp; §\C{// routine name "f" is not allowed}§
 \end{cfa}
 
@@ -2672,5 +3047,5 @@
 whereas a named (keyword) call may be:
 \begin{cfa}
-p( z : 3, x : 4, y : 7 );  $\C{// rewrite \(\Rightarrow\) p( 4, 7, 3 )}$
+p( z : 3, x : 4, y : 7 );  §\C{// rewrite \(\Rightarrow\) p( 4, 7, 3 )}§
 \end{cfa}
 Here the order of the arguments is unimportant, and the names of the parameters are used to associate argument values with the corresponding parameters.
@@ -2689,9 +3064,9 @@
 For example, the following routine prototypes and definition are all valid.
 \begin{cfa}
-void p( int, int, int ); $\C{// equivalent prototypes}$
+void p( int, int, int ); §\C{// equivalent prototypes}§
 void p( int x, int y, int z );
 void p( int y, int x, int z );
 void p( int z, int y, int x );
-void p( int q, int r, int s ) {} $\C{// match with this definition}$
+void p( int q, int r, int s ) {} §\C{// match with this definition}§
 \end{cfa}
 Forcing matching parameter names in routine prototypes with corresponding routine definitions is possible, but goes against a strong tradition in C programming.
@@ -2705,11 +3080,11 @@
 int f( int x, double y );
 
-f( j : 3, i : 4 ); $\C{// 1st f}$
-f( x : 7, y : 8.1 ); $\C{// 2nd f}$
-f( 4, 5 );  $\C{// ambiguous call}$
+f( j : 3, i : 4 ); §\C{// 1st f}§
+f( x : 7, y : 8.1 ); §\C{// 2nd f}§
+f( 4, 5 );  §\C{// ambiguous call}§
 \end{cfa}
 However, named arguments compound routine resolution in conjunction with conversions:
 \begin{cfa}
-f( i : 3, 5.7 ); $\C{// ambiguous call ?}$
+f( i : 3, 5.7 ); §\C{// ambiguous call ?}§
 \end{cfa}
 Depending on the cost associated with named arguments, this call could be resolvable or ambiguous.
@@ -2725,16 +3100,16 @@
 the allowable positional calls are:
 \begin{cfa}
-p(); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}$
-p( 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}$
-p( 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}$
-p( 4, 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 4 )}$
+p(); §\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}§
+p( 4 ); §\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}§
+p( 4, 4 ); §\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}§
+p( 4, 4, 4 ); §\C{// rewrite \(\Rightarrow\) p( 4, 4, 4 )}§
 // empty arguments
-p(  , 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 1, 4, 4 )}$
-p( 4,  , 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 4 )}$
-p( 4, 4,   ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}$
-p( 4,  ,   ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}$
-p(  , 4,   ); $\C{// rewrite \(\Rightarrow\) p( 1, 4, 3 )}$
-p(  ,  , 4 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 4 )}$
-p(  ,  ,   ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}$
+p(  , 4, 4 ); §\C{// rewrite \(\Rightarrow\) p( 1, 4, 4 )}§
+p( 4,  , 4 ); §\C{// rewrite \(\Rightarrow\) p( 4, 2, 4 )}§
+p( 4, 4,   ); §\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}§
+p( 4,  ,   ); §\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}§
+p(  , 4,   ); §\C{// rewrite \(\Rightarrow\) p( 1, 4, 3 )}§
+p(  ,  , 4 ); §\C{// rewrite \(\Rightarrow\) p( 1, 2, 4 )}§
+p(  ,  ,   ); §\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}§
 \end{cfa}
 Here the missing arguments are inserted from the default values in the parameter list.
@@ -2760,7 +3135,7 @@
 Default values may only appear in a prototype versus definition context:
 \begin{cfa}
-void p( int x, int y = 2, int z = 3 ); $\C{// prototype: allowed}$
-void p( int, int = 2, int = 3 ); $\C{// prototype: allowed}$
-void p( int x, int y = 2, int z = 3 ) {} $\C{// definition: not allowed}$
+void p( int x, int y = 2, int z = 3 ); §\C{// prototype: allowed}§
+void p( int, int = 2, int = 3 ); §\C{// prototype: allowed}§
+void p( int x, int y = 2, int z = 3 ) {} §\C{// definition: not allowed}§
 \end{cfa}
 The reason for this restriction is to allow separate compilation.
@@ -2777,6 +3152,6 @@
 \begin{cfa}
 p( int x, int y, int z, ... );
-p( 1, 4, 5, 6, z : 3, y : 2 ); $\C{// assume p( /* positional */, ... , /* named */ );}$
-p( 1, z : 3, y : 2, 4, 5, 6 ); $\C{// assume p( /* positional */, /* named */, ... );}$
+p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
+p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
 \end{cfa}
 In the first call, it is necessary for the programmer to conceptually rewrite the call, changing named arguments into positional, before knowing where the ellipse arguments begin.
@@ -2787,6 +3162,6 @@
 \begin{cfa}
 void p( int x, int y = 2, int z = 3... );
-p( 1, 4, 5, 6, z : 3 ); $\C{// assume p( /* positional */, ... , /* named */ );}$
-p( 1, z : 3, 4, 5, 6 ); $\C{// assume p( /* positional */, /* named */, ... );}$
+p( 1, 4, 5, 6, z : 3 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
+p( 1, z : 3, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
 \end{cfa}
 The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments;
@@ -2818,5 +3193,5 @@
 Furthermore, overloading cannot handle accessing default arguments in the middle of a positional list, via a missing argument, such as:
 \begin{cfa}
-p( 1, /* default */, 5 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 5 )}$
+p( 1, /* default */, 5 ); §\C{// rewrite \(\Rightarrow\) p( 1, 2, 5 )}§
 \end{cfa}
 
@@ -2831,10 +3206,10 @@
 \begin{cfa}
 struct {
-	int f1; $\C{// named field}$
-	int f2 : 4; $\C{// named field with bit field size}$
-	int : 3; $\C{// unnamed field for basic type with bit field size}$
-	int ; $\C{// disallowed, unnamed field}$
-	int *; $\C{// disallowed, unnamed field}$
-	int (*)( int ); $\C{// disallowed, unnamed field}$
+	int f1; §\C{// named field}§
+	int f2 : 4; §\C{// named field with bit field size}§
+	int : 3; §\C{// unnamed field for basic type with bit field size}§
+	int ; §\C{// disallowed, unnamed field}§
+	int *; §\C{// disallowed, unnamed field}§
+	int (*)( int ); §\C{// disallowed, unnamed field}§
 };
 \end{cfa}
@@ -2844,5 +3219,5 @@
 \begin{cfa}
 struct {
-	int , , ; $\C{// 3 unnamed fields}$
+	int , , ; §\C{// 3 unnamed fields}§
 }
 \end{cfa}
@@ -2938,9 +3313,9 @@
 const unsigned int size = 5;
 int ia[size];
-... $\C{// assign values to array ia}$
-qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$
+... §\C{// assign values to array ia}§
+qsort( ia, size ); §\C{// sort ascending order using builtin ?<?}§
 {
-	®int ?<?( int x, int y ) { return x > y; }® $\C{// nested routine}$
-	qsort( ia, size ); $\C{// sort descending order by local redefinition}$
+	®int ?<?( int x, int y ) { return x > y; }® §\C{// nested routine}§
+	qsort( ia, size ); §\C{// sort descending order by local redefinition}§
 }
 \end{cfa}
@@ -2950,14 +3325,14 @@
 The following program in undefined in \CFA (and Indexc{gcc})
 \begin{cfa}
-[* [int]( int )] foo() { $\C{// int (* foo())( int )}$
+[* [int]( int )] foo() { §\C{// int (* foo())( int )}§
 	int ®i® = 7;
 	int bar( int p ) {
-		®i® += 1; $\C{// dependent on local variable}$
+		®i® += 1; §\C{// dependent on local variable}§
 		sout | ®i®;
 	}
-	return bar; $\C{// undefined because of local dependence}$
+	return bar; §\C{// undefined because of local dependence}§
 }
 int main() {
-	* [int]( int ) fp = foo(); $\C{// int (* fp)( int )}$
+	* [int]( int ) fp = foo(); §\C{// int (* fp)( int )}§
 	sout | fp( 3 );
 }
@@ -2972,5 +3347,5 @@
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
 \begin{cfa}
-f( ®2, x, 3 + i® ); $\C{// element list}$
+f( ®2, x, 3 + i® ); §\C{// element list}§
 \end{cfa}
 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
@@ -2987,8 +3362,8 @@
 For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value.
 \begin{cfa}
-typedef struct { int quot, rem; } div_t;	$\C[7cm]{// from include stdlib.h}$
+typedef struct { int quot, rem; } div_t;	§\C[7cm]{// from include stdlib.h}§
 div_t div( int num, int den );
-div_t qr = div( 13, 5 ); $\C{// return quotient/remainder aggregate}$
-printf( "%d %d\n", qr.quot, qr.rem ); $\C{// print quotient/remainder}$
+div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§
+printf( "%d %d\n", qr.quot, qr.rem ); §\C{// print quotient/remainder}§
 \end{cfa}
 This approach requires a name for the return type and fields, where \Index{naming} is a common programming-language issue.
@@ -3000,7 +3375,7 @@
 For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value.
 \begin{cfa}
-double modf( double x, double * i ); $\C{// from include math.h}$
-double intp, frac = modf( 13.5, &intp ); $\C{// return integral and fractional components}$
-printf( "%g %g\n", intp, frac ); $\C{// print integral/fractional components}$
+double modf( double x, double * i ); §\C{// from include math.h}§
+double intp, frac = modf( 13.5, &intp ); §\C{// return integral and fractional components}§
+printf( "%g %g\n", intp, frac ); §\C{// print integral/fractional components}§
 \end{cfa}
 This approach requires allocating storage for the return values, which complicates the call site with a sequence of variable declarations leading to the call.
@@ -3029,8 +3404,8 @@
 When a function call is passed as an argument to another call, the best match of actual arguments to formal parameters is evaluated given all possible expression interpretations in the current scope.
 \begin{cfa}
-void g( int, int ); $\C{// 1}$
-void g( double, double ); $\C{// 2}$
-g( div( 13, 5 ) ); $\C{// select 1}$
-g( modf( 13.5 ) ); $\C{// select 2}$
+void g( int, int ); §\C{// 1}§
+void g( double, double ); §\C{// 2}§
+g( div( 13, 5 ) ); §\C{// select 1}§
+g( modf( 13.5 ) ); §\C{// select 2}§
 \end{cfa}
 In this case, there are two overloaded ©g© routines.
@@ -3041,9 +3416,9 @@
 The previous examples can be rewritten passing the multiple returned-values directly to the ©printf© function call.
 \begin{cfa}
-[ int, int ] div( int x, int y ); $\C{// from include stdlib}$
-printf( "%d %d\n", div( 13, 5 ) ); $\C{// print quotient/remainder}$
-
-[ double, double ] modf( double x ); $\C{// from include math}$
-printf( "%g %g\n", modf( 13.5 ) ); $\C{// print integral/fractional components}$
+[ int, int ] div( int x, int y ); §\C{// from include stdlib}§
+printf( "%d %d\n", div( 13, 5 ) ); §\C{// print quotient/remainder}§
+
+[ double, double ] modf( double x ); §\C{// from include math}§
+printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§
 \end{cfa}
 This approach provides the benefits of compile-time checking for appropriate return statements as in aggregation, but without the required verbosity of declaring a new named type.
@@ -3055,6 +3430,6 @@
 \begin{cfa}
 int quot, rem;
-[ quot, rem ] = div( 13, 5 ); $\C{// assign multiple variables}$
-printf( "%d %d\n", quot, rem ); $\C{// print quotient/remainder}\CRT$
+[ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§
+printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§
 \end{cfa}
 Here, the multiple return-values are matched in much the same way as passing multiple return-values to multiple parameters in a call.
@@ -3085,6 +3460,6 @@
 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
 \begin{cfa}
-[int, int] ®qr® = div( 13, 5 ); $\C{// initialize tuple variable}$
-printf( "%d %d\n", ®qr® ); $\C{// print quotient/remainder}$
+[int, int] ®qr® = div( 13, 5 ); §\C{// initialize tuple variable}§
+printf( "%d %d\n", ®qr® ); §\C{// print quotient/remainder}§
 \end{cfa}
 It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
@@ -3092,5 +3467,5 @@
 One way to access the individual components of a tuple variable is with assignment.
 \begin{cfa}
-[ quot, rem ] = qr; $\C{// assign multiple variables}$
+[ quot, rem ] = qr; §\C{// assign multiple variables}§
 \end{cfa}
 
@@ -3115,9 +3490,9 @@
 [int, double] * p;
 
-int y = x.0; $\C{// access int component of x}$
-y = f().1; $\C{// access int component of f}$
-p->0 = 5; $\C{// access int component of tuple pointed-to by p}$
-g( x.1, x.0 ); $\C{// rearrange x to pass to g}$
-double z = [ x, f() ].0.1; $\C{// access second component of first component of tuple expression}$
+int y = x.0; §\C{// access int component of x}§
+y = f().1; §\C{// access int component of f}§
+p->0 = 5; §\C{// access int component of tuple pointed-to by p}§
+g( x.1, x.0 ); §\C{// rearrange x to pass to g}§
+double z = [ x, f() ].0.1; §\C{// access second component of first component of tuple expression}§
 \end{cfa}
 Tuple-index expressions can occur on any tuple-typed expression, including tuple-returning functions, square-bracketed tuple expressions, and other tuple-index expressions, provided the retrieved component is also a tuple.
@@ -3187,8 +3562,8 @@
 double y;
 [int, double] z;
-[y, x] = 3.14; $\C{// mass assignment}$
-[x, y] = z;							    $\C{// multiple assignment}$
-z = 10;							        $\C{// mass assignment}$
-z = [x, y]; $\C{// multiple assignment}$
+[y, x] = 3.14; §\C{// mass assignment}§
+[x, y] = z;							    §\C{// multiple assignment}§
+z = 10;							        §\C{// mass assignment}§
+z = [x, y]; §\C{// multiple assignment}§
 \end{cfa}
 Let $L_i$ for $i$ in $[0, n)$ represent each component of the flattened left side, $R_i$ represent each component of the flattened right side of a multiple assignment, and $R$ represent the right side of a mass assignment.
@@ -3198,5 +3573,5 @@
 \begin{cfa}
 [ int, int ] x, y, z;
-[ x, y ] = z;						   $\C{// multiple assignment, invalid 4 != 2}$
+[ x, y ] = z;						   §\C{// multiple assignment, invalid 4 != 2}§
 \end{cfa}
 Multiple assignment assigns $R_i$ to $L_i$ for each $i$.
@@ -3234,5 +3609,5 @@
 	double c, d;
 	[ void ] f( [ int, int ] );
-	f( [ c, a ] = [ b, d ] = 1.5 ); $\C{// assignments in parameter list}$
+	f( [ c, a ] = [ b, d ] = 1.5 ); §\C{// assignments in parameter list}§
 \end{cfa}
 The tuple expression begins with a mass assignment of ©1.5© into ©[b, d]©, which assigns ©1.5© into ©b©, which is truncated to ©1©, and ©1.5© into ©d©, producing the tuple ©[1, 1.5]© as a result.
@@ -3247,12 +3622,12 @@
 \begin{cfa}
 struct S;
-void ?{}(S *); $\C{// (1)}$
-void ?{}(S *, int); $\C{// (2)}$
-void ?{}(S * double); $\C{// (3)}$
-void ?{}(S *, S); $\C{// (4)}$
-
-[S, S] x = [3, 6.28]; $\C{// uses (2), (3), specialized constructors}$
-[S, S] y; $\C{// uses (1), (1), default constructor}$
-[S, S] z = x.0; $\C{// uses (4), (4), copy constructor}$
+void ?{}(S *); §\C{// (1)}§
+void ?{}(S *, int); §\C{// (2)}§
+void ?{}(S * double); §\C{// (3)}§
+void ?{}(S *, S); §\C{// (4)}§
+
+[S, S] x = [3, 6.28]; §\C{// uses (2), (3), specialized constructors}§
+[S, S] y; §\C{// uses (1), (1), default constructor}§
+[S, S] z = x.0; §\C{// uses (4), (4), copy constructor}§
 \end{cfa}
 In this example, ©x© is initialized by the multiple constructor calls ©?{}(&x.0, 3)© and ©?{}(&x.1, 6.28)©, while ©y© is initialized by two default constructor calls ©?{}(&y.0)© and ©?{}(&y.1)©.
@@ -3295,6 +3670,6 @@
 A member-access tuple may be used anywhere a tuple can be used, \eg:
 \begin{cfa}
-s.[ y, z, x ] = [ 3, 3.2, 'x' ]; $\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}$
-f( s.[ y, z ] ); $\C{// equivalent to f( s.y, s.z )}$
+s.[ y, z, x ] = [ 3, 3.2, 'x' ]; §\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}§
+f( s.[ y, z ] ); §\C{// equivalent to f( s.y, s.z )}§
 \end{cfa}
 Note, the fields appearing in a record-field tuple may be specified in any order;
@@ -3306,6 +3681,6 @@
 void f( double, long );
 
-f( x.[ 0, 3 ] ); $\C{// f( x.0, x.3 )}$
-x.[ 0, 1 ] = x.[ 1, 0 ]; $\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}$
+f( x.[ 0, 3 ] ); §\C{// f( x.0, x.3 )}§
+x.[ 0, 1 ] = x.[ 1, 0 ]; §\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}§
 [ long, int, long ] y = x.[ 2, 0, 2 ];
 \end{cfa}
@@ -3324,5 +3699,5 @@
 \begin{cfa}
 [ int, float, double ] f();
-[ double, float ] x = f().[ 2, 1 ]; $\C{// f() called once}$
+[ double, float ] x = f().[ 2, 1 ]; §\C{// f() called once}§
 \end{cfa}
 
@@ -3337,9 +3712,9 @@
 That is, a cast can be used to select the type of an expression when it is ambiguous, as in the call to an overloaded function.
 \begin{cfa}
-int f(); $\C{// (1)}$
-double f(); $\C{// (2)}$
-
-f(); $\C{// ambiguous - (1),(2) both equally viable}$
-(int)f(); $\C{// choose (2)}$
+int f(); §\C{// (1)}§
+double f(); §\C{// (2)}§
+
+f(); §\C{// ambiguous - (1),(2) both equally viable}§
+(int)f(); §\C{// choose (2)}§
 \end{cfa}
 Since casting is a fundamental operation in \CFA, casts need to be given a meaningful interpretation in the context of tuples.
@@ -3349,9 +3724,9 @@
 void g();
 
-(void)f(); $\C{// valid, ignore results}$
-(int)g(); $\C{// invalid, void cannot be converted to int}$
+(void)f(); §\C{// valid, ignore results}§
+(int)g(); §\C{// invalid, void cannot be converted to int}§
 
 struct A { int x; };
-(struct A)f(); $\C{// invalid, int cannot be converted to A}$
+(struct A)f(); §\C{// invalid, int cannot be converted to A}§
 \end{cfa}
 In C, line 4 is a valid cast, which calls ©f© and discards its result.
@@ -3369,9 +3744,9 @@
 	[int, [int, int], int] g();
 
-	([int, double])f(); $\C{// (1) valid}$
-	([int, int, int])g(); $\C{// (2) valid}$
-	([void, [int, int]])g(); $\C{// (3) valid}$
-	([int, int, int, int])g(); $\C{// (4) invalid}$
-	([int, [int, int, int]])g(); $\C{// (5) invalid}$
+	([int, double])f(); §\C{// (1) valid}§
+	([int, int, int])g(); §\C{// (2) valid}§
+	([void, [int, int]])g(); §\C{// (3) valid}§
+	([int, int, int, int])g(); §\C{// (4) invalid}§
+	([int, [int, int, int]])g(); §\C{// (5) invalid}§
 \end{cfa}
 
@@ -3433,8 +3808,8 @@
 void f([int, int], int, int);
 
-f([0, 0], 0, 0); $\C{// no cost}$
-f(0, 0, 0, 0); $\C{// cost for structuring}$
-f([0, 0,], [0, 0]); $\C{// cost for flattening}$
-f([0, 0, 0], 0); $\C{// cost for flattening and structuring}$
+f([0, 0], 0, 0); §\C{// no cost}§
+f(0, 0, 0, 0); §\C{// cost for structuring}§
+f([0, 0,], [0, 0]); §\C{// cost for flattening}§
+f([0, 0, 0], 0); §\C{// cost for flattening and structuring}§
 \end{cfa}
 
@@ -3500,5 +3875,5 @@
 [ unsigned int, char ]
 [ double, double, double ]
-[ * int, int * ] $\C{// mix of CFA and ANSI}$
+[ * int, int * ] §\C{// mix of CFA and ANSI}§
 [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
 \end{cfa}
@@ -3507,6 +3882,6 @@
 Examples of declarations using tuple types are:
 \begin{cfa}
-[ int, int ] x; $\C{// 2 element tuple, each element of type int}$
-* [ char, char ] y; $\C{// pointer to a 2 element tuple}$
+[ int, int ] x; §\C{// 2 element tuple, each element of type int}§
+* [ char, char ] y; §\C{// pointer to a 2 element tuple}§
 [ [ int, int ] ] z ([ int, int ]);
 \end{cfa}
@@ -3525,6 +3900,6 @@
 [ int, int ] w1;
 [ int, int, int ] w2;
-[ void ] f (int, int, int); $\C{// three input parameters of type int}$
-[ void ] g ([ int, int, int ]); $\C{3 element tuple as input}$
+[ void ] f (int, int, int); §\C{// three input parameters of type int}§
+[ void ] g ([ int, int, int ]); §\C{3 element tuple as input}§
 f( [ 1, 2, 3 ] );
 f( w1, 3 );
@@ -3607,5 +3982,5 @@
 [ int, int, int, int ] w = [ 1, 2, 3, 4 ];
 int x = 5;
-[ x, w ] = [ w, x ]; $\C{// all four tuple coercions}$
+[ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§
 \end{cfa}
 Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values;
@@ -3697,6 +4072,6 @@
 both these examples produce indeterminate results:
 \begin{cfa}
-f( x++, x++ ); $\C{// C routine call with side effects in arguments}$
-[ v1, v2 ] = [ x++, x++ ]; $\C{// side effects in right-hand side of multiple assignment}$
+f( x++, x++ ); §\C{// C routine call with side effects in arguments}§
+[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in right-hand side of multiple assignment}§
 \end{cfa}
 
@@ -3797,5 +4172,5 @@
 \begin{cfa}
 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
-sout | t1 | t2; $\C{// print tuples}$
+sout | t1 | t2; §\C{// print tuples}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
@@ -3881,5 +4256,5 @@
 
 int main( int argc, char * argv[] ) {
-	®ifstream® in  = stdin;					$\C{// copy default files}$
+	®ifstream® in  = stdin;					§\C{// copy default files}§
 	®ofstream® out = stdout;
 
@@ -3887,24 +4262,24 @@
 		choose ( argc ) {
 		  case 2, 3:
-			®open®( in, argv[1] );			$\C{// open input file first as output creates file}$
-			if ( argc == 3 ) ®open®( out, argv[2] ); $\C{// do not create output unless input opens}$
-		  case 1: ;							$\C{// use default files}$
+			®open®( in, argv[1] );			§\C{// open input file first as output creates file}§
+			if ( argc == 3 ) ®open®( out, argv[2] ); §\C{// do not create output unless input opens}§
+		  case 1: ;							§\C{// use default files}§
 		  default:
 			®exit® | "Usage" | argv[0] | "[ input-file (default stdin) "
 				   "[ output-file (default stdout) ] ]";
 		} // choose
-	} catch( ®open_failure® * ex; ex->istream == &in ) { $\C{// input file errors}$
+	} catch( ®open_failure® * ex; ex->istream == &in ) { §\C{// input file errors}§
 		®exit® | "Unable to open input file" | argv[1];
-	} catch( ®open_failure® * ex; ex->ostream == &out ) { $\C{// output file errors}$
-		®close®( in );						$\C{// optional}$
+	} catch( ®open_failure® * ex; ex->ostream == &out ) { §\C{// output file errors}§
+		®close®( in );						§\C{// optional}§
 		®exit® | "Unable to open output file" | argv[2];
 	} // try
 
-	out | nlOff;							$\C{// turn off auto newline}$
-	in | nlOn;								$\C{// turn on reading newline}$
+	out | nlOff;							§\C{// turn off auto newline}§
+	in | nlOn;								§\C{// turn on reading newline}§
 	char ch;
-	for () {								$\C{// read/write characters}$
+	for () {								§\C{// read/write characters}§
 		in | ch;
-	  if ( eof( in ) ) break;				$\C{// eof ?}$
+	  if ( eof( in ) ) break;				§\C{// eof ?}§
 		out | ch;
 	} // for
@@ -3953,28 +4328,28 @@
 // *********************************** ofstream ***********************************
 
-bool fail( ofstream & );$\indexc{fail}\index{ofstream@©ofstream©!©fail©}$
-void clear( ofstream & );$\indexc{clear}\index{ofstream@©ofstream©!©clear©}$
-int flush( ofstream & );$\indexc{flush}\index{ofstream@©ofstream©!©flush©}$
-void open( ofstream &, const char name[], const char mode[] = "w" );$\indexc{open}\index{ofstream@©ofstream©!©open©}$
-void close( ofstream & );$\indexc{close}\index{ofstream@©ofstream©!©close©}$
-ofstream & write( ofstream &, const char data[], size_t size );$\indexc{write}\index{ofstream@©ofstream©!©write©}$
-
-void ?{}( ofstream & );$\index{ofstream@©ofstream©!©?{}©}$
+bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§
+void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§
+int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§
+void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§
+void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§
+ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§
+
+void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§
 void ?{}( ofstream &, const char name[], const char mode[] = "w" );
-void ^?{}( ofstream & );$\index{ofstream@©ofstream©!©^?{}©}$
+void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§
 
 // *********************************** ifstream ***********************************
 
-bool fail( ifstream & is );$\indexc{fail}\index{ifstream@©ifstream©!©fail©}$
-void clear( ifstream & );$\indexc{clear}\index{ifstream@©ifstream©!©clear©}$
-bool eof( ifstream & is );$\indexc{eof}\index{ifstream@©ifstream©!©eof©}$
-void open( ifstream & is, const char name[], const char mode[] = "r" );$\indexc{open}\index{ifstream@©ifstream©!©open©}$
-void close( ifstream & is );$\indexc{close}\index{ifstream@©ifstream©!©close©}$
-ifstream & read( ifstream & is, char data[], size_t size );$\indexc{read}\index{ifstream@©ifstream©!©read©}$
-ifstream & ungetc( ifstream & is, char c );$\indexc{unget}\index{ifstream@©ifstream©!©unget©}$
-
-void ?{}( ifstream & is );$\index{ifstream@©ifstream©!©?{}©}$
+bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§
+void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§
+bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§
+void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§
+void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§
+ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§
+ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§
+
+void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§
 void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
-void ^?{}( ifstream & is );$\index{ifstream@©ifstream©!©^?{}©}$
+void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§
 \end{cfa}
 \caption{Stream Functions}
@@ -4063,5 +4438,5 @@
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); $\C{// set separator from " " to ", \$"}$
+sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); §\C{// set separator from " " to ", \$"}§
 sout | 1 | 2 | 3 | " \"" | ®sepVal® | "\"";
 \end{cfa}
@@ -4070,5 +4445,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, " " ); $\C{// reset separator to " "}$
+sepSet( sout, " " ); §\C{// reset separator to " "}§
 sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
 \end{cfa}
@@ -4078,7 +4453,7 @@
 ©sepGet© can be used to store a separator and then restore it:
 \begin{cfa}[belowskip=0pt]
-char store[®sepSize®]; $\C{// sepSize is the maximum separator size}$
-strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$
-sepSet( sout, "_" ); $\C{// change separator to underscore}$
+char store[®sepSize®]; §\C{// sepSize is the maximum separator size}§
+strcpy( store, sepGet( sout ) ); §\C{// copy current separator}§
+sepSet( sout, "_" ); §\C{// change separator to underscore}§
 sout | 1 | 2 | 3;
 \end{cfa}
@@ -4087,5 +4462,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, store ); $\C{// change separator back to original}$
+sepSet( sout, store ); §\C{// change separator back to original}§
 sout | 1 | 2 | 3;
 \end{cfa}
@@ -4098,5 +4473,5 @@
 The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[belowskip=0pt]
-sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
+sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§
 sout | t1 | t2 | " \"" | ®sepTupleVal® | "\"";
 \end{cfa}
@@ -4105,5 +4480,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$
+sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§
 sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
 \end{cfa}
@@ -4116,5 +4491,5 @@
 \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} and \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} globally toggle printing the separator.
 \begin{cfa}[belowskip=0pt]
-sout | ®sepOff® | 1 | 2 | 3; $\C{// turn off implicit separator}$
+sout | ®sepOff® | 1 | 2 | 3; §\C{// turn off implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4122,5 +4497,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | ®sepOn® | 1 | 2 | 3; $\C{// turn on implicit separator}$
+sout | ®sepOn® | 1 | 2 | 3; §\C{// turn on implicit separator}§
 \end{cfa}
 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4131,5 +4506,5 @@
 \Indexc{sep}\index{manipulator!sep@©sep©} and \Indexc{nosep}\index{manipulator!nosep@©nosep©} locally toggle printing the separator with respect to the next printed item, and then return to the global separator setting.
 \begin{cfa}[belowskip=0pt]
-sout | 1 | ®nosep® | 2 | 3; $\C{// turn off implicit separator for the next item}$
+sout | 1 | ®nosep® | 2 | 3; §\C{// turn off implicit separator for the next item}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4137,5 +4512,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sepOff | 1 | ®sep® | 2 | 3; $\C{// turn on implicit separator for the next item}$
+sout | sepOff | 1 | ®sep® | 2 | 3; §\C{// turn on implicit separator for the next item}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4144,5 +4519,5 @@
 The tuple separator also responses to being turned on and off.
 \begin{cfa}[belowskip=0pt]
-sout | t1 | ®nosep® | t2; $\C{// turn off implicit separator for the next item}$
+sout | t1 | ®nosep® | t2; §\C{// turn off implicit separator for the next item}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4152,5 +4527,5 @@
 Use ©sep© to accomplish this functionality.
 \begin{cfa}[belowskip=0pt]
-sout | ®sep® | 1 | 2 | 3 | ®sep®; $\C{// sep does nothing at start/end of line}$
+sout | ®sep® | 1 | 2 | 3 | ®sep®; §\C{// sep does nothing at start/end of line}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4158,5 +4533,5 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | ®sepVal® | 1 | 2 | 3 | ®sepVal® ; $\C{// use sepVal to print separator at start/end of line}$
+sout | ®sepVal® | 1 | 2 | 3 | ®sepVal® ; §\C{// use sepVal to print separator at start/end of line}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -4197,9 +4572,9 @@
 \Indexc{nl}\index{manipulator!nl@©nl©} inserts a newline.
 \begin{cfa}
-sout | ®nl®; $\C{// only print newline}$
-sout | 2; $\C{// implicit newline}$
-sout | 3 | ®nl® | 4 | ®nl®; $\C{// terminating nl merged with implicit newline}$
-sout | 5 | ®nl® | ®nl®; $\C{// again terminating nl merged with implicit newline}$
-sout | 6; $\C{// implicit newline}$
+sout | ®nl®; §\C{// only print newline}§
+sout | 2; §\C{// implicit newline}§
+sout | 3 | ®nl® | 4 | ®nl®; §\C{// terminating nl merged with implicit newline}§
+sout | 5 | ®nl® | ®nl®; §\C{// again terminating nl merged with implicit newline}§
+sout | 6; §\C{// implicit newline}§
 
 2
@@ -4648,5 +5023,5 @@
 ®mutex( sout )® {
 	sout | 1;
-	®mutex( sout ) sout® | 2 | 3;				$\C{// unnecessary, but ok because of recursive lock}$
+	®mutex( sout ) sout® | 2 | 3;				§\C{// unnecessary, but ok because of recursive lock}§
 	sout | 4;
 } // implicitly release sout lock
@@ -4660,5 +5035,5 @@
 	int x, y, z, w;
 	sin | x;
-	®mutex( sin )® sin | y | z;					$\C{// unnecessary, but ok because of recursive lock}$
+	®mutex( sin )® sin | y | z;					§\C{// unnecessary, but ok because of recursive lock}§
 	sin | w;
 } // implicitly release sin lock
@@ -4669,5 +5044,5 @@
 \Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
 \begin{cfa}
-®mutex( sout )® sout | "data:" | rtn( mon );	$\C{// mutex call on monitor}$
+®mutex( sout )® sout | "data:" | rtn( mon );	§\C{// mutex call on monitor}§
 \end{cfa}
 If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
@@ -4687,6 +5062,6 @@
 \begin{cfa}
 12®,®345®.®123		$\C[1.25in]{// comma separator, period decimal-point}$
-12®.®345®,®123		$\C{// period separator, comma decimal-point}$
-12$\Sp$345®,®123®.®	$\C{// space separator, comma decimal-point, period terminator}\CRT$
+12®.®345®,®123		§\C{// period separator, comma decimal-point}§
+12$\Sp$345®,®123®.®	§\C{// space separator, comma decimal-point, period terminator}\CRT§
 \end{cfa}
 A locale is selected with function ©setlocale©, and the corresponding locale package \emph{must} be installed on the underlying system;
@@ -4699,6 +5074,6 @@
 \begin{cfa}
 #include <fstream.hfa>
-#include <locale.h>							$\C{// setlocale}$
-#include <stdlib.h>							$\C{// getenv}$
+#include <locale.h>							§\C{// setlocale}§
+#include <stdlib.h>							§\C{// getenv}§
 
 int main() {
@@ -4772,15 +5147,15 @@
 int main() {
 	enum { size = 256 };
-	char buf[size]; $\C{// output buffer}$
-	®ostrstream osstr = { buf, size };® $\C{// bind output buffer/size}$
+	char buf[size]; §\C{// output buffer}§
+	®ostrstream osstr = { buf, size };® §\C{// bind output buffer/size}§
 	int i = 3, j = 5, k = 7;
 	double x = 12345678.9, y = 98765.4321e-11;
 
 	osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
-	write( osstr ); $\C{// write string to stdout}$
-	printf( "%s", buf ); $\C{// same lines of output}$
+	write( osstr ); §\C{// write string to stdout}§
+	printf( "%s", buf ); §\C{// same lines of output}§
 	sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
 
-	char buf2[] = "12 14 15 3.5 7e4 abc"; $\C{// input buffer}$
+	char buf2[] = "12 14 15 3.5 7e4 abc"; §\C{// input buffer}§
 	®istrstream isstr = { buf2 };®
 	char s[10];
@@ -4934,5 +5309,5 @@
 // Subsequent arguments can be specified for initialization
 
-void ?{}( Widget & w ) { $\C{// default constructor}$
+void ?{}( Widget & w ) { §\C{// default constructor}§
 	w.id = -1;
 	w.size = 0.0;
@@ -4948,5 +5323,5 @@
 
 // ^?{} is the destructor operator identifier
-void ^?{}( Widget & w ) { $\C{// destructor}$
+void ^?{}( Widget & w ) { §\C{// destructor}§
 	w.id = 0;
 	w.size = 0.0;
@@ -4957,10 +5332,10 @@
 }
 
-Widget baz; $\C{// reserve space only}$
-Widget foo{}; $\C{// calls default constructor}$
-Widget bar{ 23, 2.45 }; $\C{// calls constructor with values}$
-baz{ 24, 0.91 }; $\C{// calls constructor with values}$
-?{}( baz, 24, 0.91 ); $\C{// explicit call to constructor}$
-^?{} (bar ); $\C{// explicit call to destructor}$
+Widget baz; §\C{// reserve space only}§
+Widget foo{}; §\C{// calls default constructor}§
+Widget bar{ 23, 2.45 }; §\C{// calls constructor with values}§
+baz{ 24, 0.91 }; §\C{// calls constructor with values}§
+?{}( baz, 24, 0.91 ); §\C{// explicit call to constructor}§
+^?{} (bar ); §\C{// explicit call to destructor}§
 \end{cfa}
 \caption{Constructors and Destructors}
@@ -5480,25 +5855,25 @@
 
 ®coroutine® Fibonacci {
-	int fn; $\C{// used for communication}$
+	int fn; §\C{// used for communication}§
 };
 
-void main( Fibonacci & fib ) with( fib ) { $\C{// called on first resume}$
-	int fn1, fn2; $\C{// retained between resumes}$
-	fn = 0;  fn1 = fn; $\C{// 1st case}$
-	®suspend;® $\C{// restart last resume}$
-	fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
-	®suspend;® $\C{// restart last resume}$
+void main( Fibonacci & fib ) with( fib ) { §\C{// called on first resume}§
+	int fn1, fn2; §\C{// retained between resumes}§
+	fn = 0;  fn1 = fn; §\C{// 1st case}§
+	®suspend;® §\C{// restart last resume}§
+	fn = 1;  fn2 = fn1;  fn1 = fn; §\C{// 2nd case}§
+	®suspend;® §\C{// restart last resume}§
 	for () {
-		fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
-		®suspend;® $\C{// restart last resume}$
+		fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; §\C{// general case}§
+		®suspend;® §\C{// restart last resume}§
 	}
 }
 int next( Fibonacci & fib ) with( fib ) {
-	®resume( fib );® $\C{// restart last suspend}$
+	®resume( fib );® §\C{// restart last suspend}§
 	return fn;
 }
 int main() {
 	Fibonacci f1, f2;
-	for ( 10 ) { $\C{// print N Fibonacci values}$
+	for ( 10 ) { §\C{// print N Fibonacci values}§
 		sout | next( f1 ) | next( f2 );
 	}
@@ -5538,10 +5913,10 @@
 int inc( AtomicCnt & ®mutex® c, int inc = 1 ) with(c) { return counter += inc; }
 int dec( AtomicCnt & ®mutex® c, int dec = 1 ) with(c) { return counter -= dec; }
-forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
+forall( ostype & | ostream( ostype ) ) { §\C{// print any stream}§
 	ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
 	void ?|?( ostype & os, AtomicCnt c ) { (ostype &)(os | c.counter); ends( os ); }
 }
 
-AtomicCnt global; $\C{// shared}$
+AtomicCnt global; §\C{// shared}§
 
 thread MyThread {};
@@ -5554,9 +5929,9 @@
 int main() {
 	enum { Threads = 4 };
-	processor p[Threads - 1]; $\C{// + starting processor}$
+	processor p[Threads - 1]; §\C{// + starting processor}§
 	{
 		MyThread t[Threads];
 	}
-	sout | global; $\C{// print 0}$
+	sout | global; §\C{// print 0}§
 }
 \end{cfa}
@@ -7031,6 +7406,6 @@
 In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as:
 \begin{cfa}
-*?$\Sp$*? $\C{// dereference operator, dereference operator}$
-*$\Sp$?*? $\C{// dereference, multiplication operator}$
+*?$\Sp$*? §\C{// dereference operator, dereference operator}§
+*$\Sp$?*? §\C{// dereference, multiplication operator}§
 \end{cfa}
 By default, the first interpretation is selected, which does not yield a meaningful parse.
@@ -7084,13 +7459,13 @@
 \eg:
 \begin{cfa}
-x; $\C{// int x}$
-*y; $\C{// int *y}$
-f( p1, p2 ); $\C{// int f( int p1, int p2 );}$
-g( p1, p2 ) int p1, p2; $\C{// int g( int p1, int p2 );}$
+x; §\C{// int x}§
+*y; §\C{// int *y}§
+f( p1, p2 ); §\C{// int f( int p1, int p2 );}§
+g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§
 \end{cfa}
 \CFA continues to support K\&R routine definitions:
 \begin{cfa}
-f( a, b, c ) $\C{// default int return}$
-	int a, b; char c $\C{// K\&R parameter declarations}$
+f( a, b, c ) §\C{// default int return}§
+	int a, b; char c §\C{// K\&R parameter declarations}§
 {
 	...
@@ -7111,5 +7486,5 @@
 int rtn( int i );
 int rtn( char c );
-rtn( 'x' ); $\C{// programmer expects 2nd rtn to be called}$
+rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§
 \end{cfa}
 \item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first.
@@ -7133,6 +7508,6 @@
 \item[Change:] make string literals ©const©:
 \begin{cfa}
-char * p = "abc"; $\C{// valid in C, deprecated in \CFA}$
-char * q = expr ? "abc" : "de"; $\C{// valid in C, invalid in \CFA}$
+char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§
+char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
 \end{cfa}
 The type of a string literal is changed from ©[] char© to ©const [] char©.
@@ -7141,5 +7516,5 @@
 \begin{cfa}
 char * p = "abc";
-p[0] = 'w'; $\C{// segment fault or change constant literal}$
+p[0] = 'w'; §\C{// segment fault or change constant literal}§
 \end{cfa}
 The same problem occurs when passing a string literal to a routine that changes its argument.
@@ -7153,7 +7528,7 @@
 \item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope:
 \begin{cfa}
-int i; $\C{// forward definition}$
-int *j = ®&i®; $\C{// forward reference, valid in C, invalid in \CFA}$
-int i = 0; $\C{// definition}$
+int i; §\C{// forward definition}§
+int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§
+int i = 0; §\C{// definition}§
 \end{cfa}
 is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed.
@@ -7161,7 +7536,7 @@
 \begin{cfa}
 struct X { int i; struct X *next; };
-static struct X a; $\C{// forward definition}$
-static struct X b = { 0, ®&a® };$\C{// forward reference, valid in C, invalid in \CFA}$
-static struct X a = { 1, &b }; $\C{// definition}$
+static struct X a; §\C{// forward definition}§
+static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§
+static struct X a = { 1, &b }; §\C{// definition}§
 \end{cfa}
 \item[Rationale:] avoids having different initialization rules for builtin types and user-defined types.
@@ -7178,14 +7553,14 @@
 struct Person {
 	enum ®Colour® { R, G, B };	$\C[7cm]{// nested type}$
-	struct Face { $\C{// nested type}$
-		®Colour® Eyes, Hair; $\C{// type defined outside (1 level)}$
+	struct Face { §\C{// nested type}§
+		®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§
 	};
-	®.Colour® shirt; $\C{// type defined outside (top level)}$
-	®Colour® pants; $\C{// type defined same level}$
-	Face looks[10]; $\C{// type defined same level}$
+	®.Colour® shirt; §\C{// type defined outside (top level)}§
+	®Colour® pants; §\C{// type defined same level}§
+	Face looks[10]; §\C{// type defined same level}§
 };
-®Colour® c = R; $\C{// type/enum defined same level}$
-Person®.Colour® pc = Person®.®R;$\C{// type/enum defined inside}$
-Person®.®Face pretty; $\C{// type defined inside}\CRT$
+®Colour® c = R; §\C{// type/enum defined same level}§
+Person®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§
+Person®.®Face pretty; §\C{// type defined inside}\CRT§
 \end{cfa}
 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
@@ -7204,5 +7579,5 @@
 \item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example:
 \begin{cfa}
-struct Y; $\C{// struct Y and struct X are at the same scope}$
+struct Y; §\C{// struct Y and struct X are at the same scope}§
 struct X {
 	struct Y { /* ... */ } y;
@@ -7219,6 +7594,6 @@
 \begin{cfa}
 void foo() {
-	int * b = malloc( sizeof(int) ); $\C{// implicitly convert void * to int *}$
-	char * c = b; $\C{// implicitly convert int * to void *, and then void * to char *}$
+	int * b = malloc( sizeof(int) ); §\C{// implicitly convert void * to int *}§
+	char * c = b; §\C{// implicitly convert int * to void *, and then void * to char *}§
 }
 \end{cfa}
@@ -7462,7 +7837,7 @@
 Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in
 \begin{cfa}
-int * ip = (int *)malloc( sizeof(int) );		$\C{// C}$
-int * ip = malloc();							$\C{// \CFA type-safe version of C malloc}$
-int * ip = alloc();								$\C{// \CFA type-safe uniform alloc}$
+int * ip = (int *)malloc( sizeof(int) );		§\C{// C}§
+int * ip = malloc();							§\C{// \CFA type-safe version of C malloc}§
+int * ip = alloc();								§\C{// \CFA type-safe uniform alloc}§
 \end{cfa}
 the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©.
@@ -7471,5 +7846,5 @@
 \begin{cfa}
 struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment
-S * sp = malloc();								$\C{// honour type alignment}$
+S * sp = malloc();								§\C{// honour type alignment}§
 \end{cfa}
 the storage allocation is implicitly aligned to 128 rather than the default 16.
@@ -7486,13 +7861,13 @@
 \CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in
 \begin{cfa}
-struct S { int i; };							$\C{// cache-line alignment}$
+struct S { int i; };							§\C{// cache-line alignment}§
 void ?{}( S & s, int i ) { s.i = i; }
 // assume ?|? operator for printing an S
 
-S & sp = *®new®( 3 );							$\C{// call constructor after allocation}$
+S & sp = *®new®( 3 );							§\C{// call constructor after allocation}§
 sout | sp.i;
 ®delete®( &sp );
 
-S * spa = ®anew®( 10, 5 );						$\C{// allocate array and initialize each array element}$
+S * spa = ®anew®( 10, 5 );						§\C{// allocate array and initialize each array element}§
 for ( i; 10 ) sout | spa[i] | nonl;
 sout | nl;
@@ -7533,25 +7908,25 @@
 	// $\CFA$ safe general allocation, fill, resize, alignment, array
 	T * alloc( void );$\indexc{alloc}$					$\C[3.5in]{// variable, T size}$
-	T * alloc( size_t dim );							$\C{// array[dim], T size elements}$
-	T * alloc( T ptr[], size_t dim );					$\C{// realloc array[dim], T size elements}$
-
-	T * alloc_set( char fill );$\indexc{alloc_set}$		$\C{// variable, T size, fill bytes with value}$
-	T * alloc_set( T fill );							$\C{// variable, T size, fill with value}$
-	T * alloc_set( size_t dim, char fill );				$\C{// array[dim], T size elements, fill bytes with value}$
-	T * alloc_set( size_t dim, T fill );				$\C{// array[dim], T size elements, fill elements with value}$
-	T * alloc_set( size_t dim, const T fill[] );		$\C{// array[dim], T size elements, fill elements with array}$
-	T * alloc_set( T ptr[], size_t dim, char fill );	$\C{// realloc array[dim], T size elements, fill bytes with value}$
-
-	T * alloc_align( size_t align );					$\C{// aligned variable, T size}$
-	T * alloc_align( size_t align, size_t dim );		$\C{// aligned array[dim], T size elements}$
-	T * alloc_align( T ptr[], size_t align );			$\C{// realloc new aligned array}$
-	T * alloc_align( T ptr[], size_t align, size_t dim ); $\C{// realloc new aligned array[dim]}$
-
-	T * alloc_align_set( size_t align, char fill );		$\C{// aligned variable, T size, fill bytes with value}$
-	T * alloc_align_set( size_t align, T fill );		$\C{// aligned variable, T size, fill with value}$
-	T * alloc_align_set( size_t align, size_t dim, char fill ); $\C{// aligned array[dim], T size elements, fill bytes with value}$
-	T * alloc_align_set( size_t align, size_t dim, T fill ); $\C{// aligned array[dim], T size elements, fill elements with value}$
-	T * alloc_align_set( size_t align, size_t dim, const T fill[] ); $\C{// aligned array[dim], T size elements, fill elements with array}$
-	T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); $\C{// realloc new aligned array[dim], fill new bytes with value}$
+	T * alloc( size_t dim );							§\C{// array[dim], T size elements}§
+	T * alloc( T ptr[], size_t dim );					§\C{// realloc array[dim], T size elements}§
+
+	T * alloc_set( char fill );$\indexc{alloc_set}$		§\C{// variable, T size, fill bytes with value}§
+	T * alloc_set( T fill );							§\C{// variable, T size, fill with value}§
+	T * alloc_set( size_t dim, char fill );				§\C{// array[dim], T size elements, fill bytes with value}§
+	T * alloc_set( size_t dim, T fill );				§\C{// array[dim], T size elements, fill elements with value}§
+	T * alloc_set( size_t dim, const T fill[] );		§\C{// array[dim], T size elements, fill elements with array}§
+	T * alloc_set( T ptr[], size_t dim, char fill );	§\C{// realloc array[dim], T size elements, fill bytes with value}§
+
+	T * alloc_align( size_t align );					§\C{// aligned variable, T size}§
+	T * alloc_align( size_t align, size_t dim );		§\C{// aligned array[dim], T size elements}§
+	T * alloc_align( T ptr[], size_t align );			§\C{// realloc new aligned array}§
+	T * alloc_align( T ptr[], size_t align, size_t dim ); §\C{// realloc new aligned array[dim]}§
+
+	T * alloc_align_set( size_t align, char fill );		§\C{// aligned variable, T size, fill bytes with value}§
+	T * alloc_align_set( size_t align, T fill );		§\C{// aligned variable, T size, fill with value}§
+	T * alloc_align_set( size_t align, size_t dim, char fill ); §\C{// aligned array[dim], T size elements, fill bytes with value}§
+	T * alloc_align_set( size_t align, size_t dim, T fill ); §\C{// aligned array[dim], T size elements, fill elements with value}§
+	T * alloc_align_set( size_t align, size_t dim, const T fill[] ); §\C{// aligned array[dim], T size elements, fill elements with array}§
+	T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); §\C{// realloc new aligned array[dim], fill new bytes with value}§
 
 	// $\CFA$ safe initialization/copy, i.e., implicit size specification
@@ -7614,8 +7989,8 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-forall( T | { int ?<?( T, T ); } ) $\C{// location}$
+forall( T | { int ?<?( T, T ); } ) §\C{// location}§
 T * bsearch( T key, const T * arr, size_t dim );$\indexc{bsearch}$
 
-forall( T | { int ?<?( T, T ); } ) $\C{// position}$
+forall( T | { int ?<?( T, T ); } ) §\C{// position}§
 unsigned int bsearch( T key, const T * arr, size_t dim );
 
@@ -7624,6 +7999,6 @@
 
 forall( E | { int ?<?( E, E ); } ) {
-	E * bsearch( E key, const E * vals, size_t dim );$\indexc{bsearch}$ $\C{// location}$
-	size_t bsearch( E key, const E * vals, size_t dim );$\C{// position}$
+	E * bsearch( E key, const E * vals, size_t dim );$\indexc{bsearch}$ §\C{// location}§
+	size_t bsearch( E key, const E * vals, size_t dim );§\C{// position}§
 	E * bsearchl( E key, const E * vals, size_t dim );$\indexc{bsearchl}$
 	size_t bsearchl( E key, const E * vals, size_t dim );
@@ -7672,23 +8047,23 @@
 void srandom( unsigned int seed );$\indexc{srandom}$
 char random( void );$\indexc{random}$
-char random( char u ); $\C{// [0,u)}$
-char random( char l, char u ); $\C{// [l,u]}$
+char random( char u ); §\C{// [0,u)}§
+char random( char l, char u ); §\C{// [l,u]}§
 int random( void );
-int random( int u ); $\C{// [0,u)}$
-int random( int l, int u ); $\C{// [l,u]}$
+int random( int u ); §\C{// [0,u)}§
+int random( int l, int u ); §\C{// [l,u]}§
 unsigned int random( void );
-unsigned int random( unsigned int u ); $\C{// [0,u)}$
-unsigned int random( unsigned int l, unsigned int u ); $\C{// [l,u]}$
+unsigned int random( unsigned int u ); §\C{// [0,u)}§
+unsigned int random( unsigned int l, unsigned int u ); §\C{// [l,u]}§
 long int random( void );
-long int random( long int u ); $\C{// [0,u)}$
-long int random( long int l, long int u ); $\C{// [l,u]}$
+long int random( long int u ); §\C{// [0,u)}§
+long int random( long int l, long int u ); §\C{// [l,u]}§
 unsigned long int random( void );
-unsigned long int random( unsigned long int u ); $\C{// [0,u)}$
-unsigned long int random( unsigned long int l, unsigned long int u ); $\C{// [l,u]}$
-float random( void );						 $\C{// [0.0, 1.0)}$
-double random( void );						 $\C{// [0.0, 1.0)}$
-float _Complex random( void );				 $\C{// [0.0, 1.0)+[0.0, 1.0)i}$
-double _Complex random( void );				 $\C{// [0.0, 1.0)+[0.0, 1.0)i}$
-long double _Complex random( void );		 $\C{// [0.0, 1.0)+[0.0, 1.0)i}$
+unsigned long int random( unsigned long int u ); §\C{// [0,u)}§
+unsigned long int random( unsigned long int l, unsigned long int u ); §\C{// [l,u]}§
+float random( void );						 §\C{// [0.0, 1.0)}§
+double random( void );						 §\C{// [0.0, 1.0)}§
+float _Complex random( void );				 §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
+double _Complex random( void );				 §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
+long double _Complex random( void );		 §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
 \end{cfa}
 
@@ -7889,5 +8264,5 @@
 long double atan2( long double, long double );
 
-float atan( float, float ); $\C{// alternative name for atan2}$
+float atan( float, float ); §\C{// alternative name for atan2}§
 double atan( double, double );$\indexc{atan}$
 long double atan( long double, long double );
@@ -8116,5 +8491,5 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Duration {
-	int64_t tn; $\C{// nanoseconds}$
+	int64_t tn; §\C{// nanoseconds}§
 };
 
@@ -8261,5 +8636,5 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Time {
-	uint64_t tn; $\C{// nanoseconds since UNIX epoch}$
+	uint64_t tn; §\C{// nanoseconds since UNIX epoch}§
 };
 
@@ -8326,24 +8701,24 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-struct Clock { $\C{// virtual clock}$
-	Duration offset; $\C{// offset from computer real-time}$
+struct Clock { §\C{// virtual clock}§
+	Duration offset; §\C{// offset from computer real-time}§
 };
 
-void ?{}( Clock & clk ); $\C{// create no offset}$
-void ?{}( Clock & clk, Duration adj ); $\C{// create with offset}$
-void reset( Clock & clk, Duration adj ); $\C{// change offset}$
-
-Duration resolutionHi(); $\C{// clock resolution in nanoseconds (fine)}$
-Duration resolution(); $\C{// clock resolution without nanoseconds (coarse)}$
-
-Time timeHiRes(); $\C{// real time with nanoseconds}$
-Time time(); $\C{// real time without nanoseconds}$
-Time time( Clock & clk ); $\C{// real time for given clock}$
-Time ?()( Clock & clk ); $\C{//\ \ \ \ alternative syntax}$
-timeval time( Clock & clk ); $\C{// convert to C time format}$
+void ?{}( Clock & clk ); §\C{// create no offset}§
+void ?{}( Clock & clk, Duration adj ); §\C{// create with offset}§
+void reset( Clock & clk, Duration adj ); §\C{// change offset}§
+
+Duration resolutionHi(); §\C{// clock resolution in nanoseconds (fine)}§
+Duration resolution(); §\C{// clock resolution without nanoseconds (coarse)}§
+
+Time timeHiRes(); §\C{// real time with nanoseconds}§
+Time time(); §\C{// real time without nanoseconds}§
+Time time( Clock & clk ); §\C{// real time for given clock}§
+Time ?()( Clock & clk ); §\C{//\ \ \ \ alternative syntax}§
+timeval time( Clock & clk ); §\C{// convert to C time format}§
 tm time( Clock & clk );
-Duration processor(); $\C{// non-monotonic duration of kernel thread}$
-Duration program(); $\C{// non-monotonic duration of program CPU}$
-Duration boot(); $\C{// monotonic duration since computer boot}$
+Duration processor(); §\C{// non-monotonic duration of kernel thread}§
+Duration program(); §\C{// non-monotonic duration of program CPU}§
+Duration boot(); §\C{// monotonic duration since computer boot}§
 \end{cfa}
 
@@ -8386,12 +8761,12 @@
 \begin{cfa}
 struct PRNG { ... }; $\C[3.75in]{// opaque type}$
-void ?{}( PRNG & prng ); $\C{// random seed}$
-void ?{}( PRNG & prng, uint32_t seed ); $\C{// fixed seed}$
-void set_seed( PRNG & prng, uint32_t seed ); $\C{// set seed}$
-uint32_t get_seed( PRNG & prng ); $\C{// get seed}$
-uint32_t prng( PRNG & prng ); $\C{// [0,UINT\_MAX]}$
-uint32_t prng( PRNG & prng, uint32_t u ); $\C{// [0,u)}$
-uint32_t prng( PRNG & prng, uint32_t l, uint32_t u ); $\C{// [l,u]}$
-uint32_t calls( PRNG & prng ); $\C{// number of calls}\CRT$
+void ?{}( PRNG & prng ); §\C{// random seed}§
+void ?{}( PRNG & prng, uint32_t seed ); §\C{// fixed seed}§
+void set_seed( PRNG & prng, uint32_t seed ); §\C{// set seed}§
+uint32_t get_seed( PRNG & prng ); §\C{// get seed}§
+uint32_t prng( PRNG & prng ); §\C{// [0,UINT\_MAX]}§
+uint32_t prng( PRNG & prng, uint32_t u ); §\C{// [0,u)}§
+uint32_t prng( PRNG & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§
+uint32_t calls( PRNG & prng ); §\C{// number of calls}\CRT§
 \end{cfa}
 A ©PRNG© object is used to randomize behaviour or values during execution, \eg in games, a character makes a random move or an object takes on a random value.
@@ -8447,13 +8822,13 @@
 \begin{cfa}
 void set_seed( uint32_t seed ); $\C[3.75in]{// set global seed}$
-uint32_t get_seed(); $\C{// get global seed}$
+uint32_t get_seed(); §\C{// get global seed}§
 // SLOWER
-uint32_t prng(); $\C{// [0,UINT\_MAX]}$
-uint32_t prng( uint32_t u ); $\C{// [0,u)}$
-uint32_t prng( uint32_t l, uint32_t u ); $\C{// [l,u]}$
+uint32_t prng(); §\C{// [0,UINT\_MAX]}§
+uint32_t prng( uint32_t u ); §\C{// [0,u)}§
+uint32_t prng( uint32_t l, uint32_t u ); §\C{// [l,u]}§
 // FASTER
-uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th );	$\C{// [0,UINT\_MAX]}$
-uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t u );	$\C{// [0,u)}$
-uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t l, uint32_t u );	$\C{// [l,u]}\CRT$
+uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th );	§\C{// [0,UINT\_MAX]}§
+uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t u );	§\C{// [0,u)}§
+uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t l, uint32_t u );	§\C{// [l,u]}\CRT§
 \end{cfa}
 The only difference between the two sets of ©prng© routines is performance.
@@ -8536,5 +8911,5 @@
 
 \begin{cfa}
-void ?{}( Int * this ); $\C{// constructor/destructor}$
+void ?{}( Int * this ); §\C{// constructor/destructor}§
 void ?{}( Int * this, Int init );
 void ?{}( Int * this, zero_t );
@@ -8545,5 +8920,5 @@
 void ^?{}( Int * this );
 
-Int ?=?( Int * lhs, Int rhs ); $\C{// assignment}$
+Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§
 Int ?=?( Int * lhs, long int rhs );
 Int ?=?( Int * lhs, unsigned long int rhs );
@@ -8562,5 +8937,5 @@
 unsigned long int narrow( Int val );
 
-int ?==?( Int oper1, Int oper2 ); $\C{// comparison}$
+int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§
 int ?==?( Int oper1, long int oper2 );
 int ?==?( long int oper2, Int oper1 );
@@ -8598,5 +8973,5 @@
 int ?>=?( unsigned long int oper1, Int oper2 );
 
-Int +?( Int oper ); $\C{// arithmetic}$
+Int +?( Int oper ); §\C{// arithmetic}§
 Int -?( Int oper );
 Int ~?( Int oper );
@@ -8680,5 +9055,5 @@
 Int ?>>=?( Int * lhs, mp_bitcnt_t shift );
 
-Int abs( Int oper ); $\C{// number functions}$
+Int abs( Int oper ); §\C{// number functions}§
 Int fact( unsigned long int N );
 Int gcd( Int oper1, Int oper2 );
@@ -8692,5 +9067,5 @@
 Int sqrt( Int oper );
 
-forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp );  $\C{// I/O}$
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp );  §\C{// I/O}§
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
 \end{cfa}
@@ -8791,8 +9166,8 @@
 // implementation
 struct Rational {$\indexc{Rational}$
-	long int numerator, denominator; $\C{// invariant: denominator > 0}$
+	long int numerator, denominator; §\C{// invariant: denominator > 0}§
 }; // Rational
 
-Rational rational(); $\C{// constructors}$
+Rational rational(); §\C{// constructors}§
 Rational rational( long int n );
 Rational rational( long int n, long int d );
@@ -8800,10 +9175,10 @@
 void ?{}( Rational * r, one_t );
 
-long int numerator( Rational r ); $\C{// numerator/denominator getter/setter}$
+long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§
 long int numerator( Rational r, long int n );
 long int denominator( Rational r );
 long int denominator( Rational r, long int d );
 
-int ?==?( Rational l, Rational r ); $\C{// comparison}$
+int ?==?( Rational l, Rational r ); §\C{// comparison}§
 int ?!=?( Rational l, Rational r );
 int ?<?( Rational l, Rational r );
@@ -8812,5 +9187,5 @@
 int ?>=?( Rational l, Rational r );
 
-Rational -?( Rational r ); $\C{// arithmetic}$
+Rational -?( Rational r ); §\C{// arithmetic}§
 Rational ?+?( Rational l, Rational r );
 Rational ?-?( Rational l, Rational r );
@@ -8818,5 +9193,5 @@
 Rational ?/?( Rational l, Rational r );
 
-double widen( Rational r ); $\C{// conversion}$
+double widen( Rational r ); §\C{// conversion}§
 Rational narrow( double f, long int md );
 
