Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision 387c9a1380c2073ad82b477bb8b65388dc6393cc)
+++ doc/papers/general/Paper.tex	(revision 3d60c08ac51fee59e5e460399d8f60bfa15e20c6)
@@ -60,5 +60,5 @@
 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
 
-\renewcommand*{\thefootnote}{\alph{footnote}} % hack because fnsymbol does not work
+\renewcommand*{\thefootnote}{\Alph{footnote}} % hack because fnsymbol does not work
 %\renewcommand*{\thefootnote}{\fnsymbol{footnote}}
 
@@ -249,5 +249,5 @@
 All languages features discussed in this paper are working, except some advanced exception-handling features.
 Not discussed in this paper are the integrated concurrency-constructs and user-level threading-library~\cite{Delisle18}.
-\CFA is an \emph{open-source} project implemented as an source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3).
+\CFA is an \emph{open-source} project implemented as a source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3).
 Ultimately, a compiler is necessary for advanced features and optimal performance.
 % @plg2[9]% cd cfa-cc/src; cloc ArgTweak CodeGen CodeTools Common Concurrency ControlStruct Designators GenPoly InitTweak MakeLibCfa.cc MakeLibCfa.h Parser ResolvExpr SymTab SynTree Tuples driver prelude main.cc 
@@ -323,5 +323,5 @@
 There are only two hard things in Computer Science: cache invalidation and \emph{naming things} -- Phil Karlton
 \end{quote}
-\vspace{-10pt}
+\vspace{-9pt}
 C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax. 
 \CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable;
@@ -438,5 +438,5 @@
 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
 
-To reducing duplication, it is possible to distribute a group of @forall@ (and storage-class qualifiers) over functions/types, so each block declaration is prefixed by the group (see example in Appendix~\ref{s:CforallStack}).
+To reduce duplication, it is possible to distribute a group of @forall@ (and storage-class qualifiers) over functions/types, so each block declaration is prefixed by the group (see example in Appendix~\ref{s:CforallStack}).
 \begin{cfa}
 forall( otype `T` ) {							$\C{// distribution block, add forall qualifier to declarations}$
@@ -480,5 +480,6 @@
 \end{cquote}
 
-In fact, the set of @summable@ trait operators is incomplete, as it is missing assignment for type @T@, but @otype@ is syntactic sugar for the following implicit trait:
+Note, the @sumable@ trait does not include a copy constructor needed for the right side of @?+=?@ and return;
+it is provided by @otype@, which is syntactic sugar for the following trait:
 \begin{cfa}
 trait otype( dtype T | sized(T) ) {  // sized is a pseudo-trait for types with known size and alignment
@@ -498,5 +499,5 @@
 Instead, each polymorphic function (or generic type) defines the structural type needed for its execution (polymorphic type-key), and this key is fulfilled at each call site from the lexical environment, which is similar to Go~\cite{Go} interfaces.
 Hence, new lexical scopes and nested functions are used extensively to create local subtypes, as in the @qsort@ example, without having to manage a nominal-inheritance hierarchy.
-(Nominal inheritance can be approximated with traits using marker variables or functions, as is done in Go.)
+% (Nominal inheritance can be approximated with traits using marker variables or functions, as is done in Go.)
 
 % Nominal inheritance can be simulated with traits using marker variables or functions:
@@ -525,5 +526,4 @@
 
 
-\vspace*{-2pt}
 \section{Generic Types}
 
@@ -571,5 +571,6 @@
 Concrete types have a fixed memory layout regardless of type parameters, while dynamic types vary in memory layout depending on their type parameters.
 A \newterm{dtype-static} type has polymorphic parameters but is still concrete.
-Polymorphic pointers are an example of dtype-static types, \eg @forall(dtype T) T *@ is a polymorphic type, but for any @T@, @T *@  is a fixed-sized pointer, and therefore, can be represented by a @void *@ in code generation.
+Polymorphic pointers are an example of dtype-static types;
+given some type variable @T@, @T@ is a polymorphic type, as is @T *@, but @T *@ has a fixed size and can therefore be represented by @void *@ in code generation.
 
 \CFA generic types also allow checked argument-constraints.
@@ -955,13 +956,13 @@
 }
 \end{cfa}
-One more step permits the summation of any summable type with all arguments of the same type:
-\begin{cfa}
-trait summable( otype T ) {
+One more step permits the summation of any sumable type with all arguments of the same type:
+\begin{cfa}
+trait sumable( otype T ) {
 	T ?+?( T, T );
 };
-forall( otype R | summable( R ) ) R sum( R x, R y ) {
+forall( otype R | sumable( R ) ) R sum( R x, R y ) {
 	return x + y;
 }
-forall( otype R, ttype Params | summable(R) | { R sum(R, Params); } ) R sum(R x, R y, Params rest) {
+forall( otype R, ttype Params | sumable(R) | { R sum(R, Params); } ) R sum(R x, R y, Params rest) {
 	return sum( x + y, rest );
 }
@@ -1108,6 +1109,6 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l|@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 case 2, 10, 34, 42:
@@ -1124,5 +1125,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 case 2~42:
@@ -1178,5 +1179,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 `choose` ( day ) {
@@ -1224,5 +1225,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{non-terminator}}	& \multicolumn{1}{c}{\textbf{target label}}	\\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{non-terminator}}	& \multicolumn{1}{c@{}}{\textbf{target label}}	\\
 \begin{cfa}
 choose ( ... ) {
@@ -1268,5 +1269,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{\hspace{\parindentlnth}}l|@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{@{\hspace{\parindentlnth}}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}	\\
+\multicolumn{1}{@{\hspace{\parindentlnth}}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{@{\hspace{\parindentlnth}}c@{}}{\textbf{C}}	\\
 \begin{cfa}
 `LC:` {
@@ -1364,5 +1365,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l|@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{Resumption}}	& \multicolumn{1}{c}{\textbf{Termination}}	\\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{Resumption}}	& \multicolumn{1}{c@{}}{\textbf{Termination}}	\\
 \begin{cfa}
 `exception R { int fix; };`
@@ -1632,5 +1633,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 `[5] *` int x1;
@@ -1660,5 +1661,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 `*` int x, y;
@@ -1681,5 +1682,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{C}}	\\
 \begin{cfa}
 [ 5 ] int z;
@@ -1723,5 +1724,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{C}}	\\
 \begin{cfa}
 extern const * const int x;
@@ -1748,5 +1749,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 y = (* int)x;
@@ -1776,5 +1777,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 [double] foo(), foo( int ), foo( double ) {...}
@@ -1794,5 +1795,5 @@
 * [ * int ] ( int y ) gp;		$\C{// pointer to function returning pointer to int with int parameter}$
 * [ ] ( int, char ) hp;			$\C{// pointer to function returning no result with int and char parameters}$
-* [ * int, int ] ( int ) jp;	$\C{// pointer to function returning pointer to int and int with int parameter}$
+* [ * int, int ] ( int ) jp;	$\C{// pointer to function returning pointer to int and int with int parameter}\CRT$
 \end{cfa}
 Note, the name of the function pointer is specified last, as for other variable declarations.
@@ -1993,8 +1994,8 @@
 The symbol \lstinline+^+ is used for the destructor name because it was the last binary operator that could be used in a unary context.}.
 The name @{}@ comes from the syntax for the initializer: @struct S { int i, j; } s = `{` 2, 3 `}`@.
-Like other \CFA operators, these names represent the syntax used to call the constructor or destructor, \eg @?{}(x, ...)@ or @^{}(x, ...)@.
+Like other \CFA operators, these names represent the syntax used to explicitly call the constructor or destructor, \eg @s{...}@ or @^s{...}@.
 The constructor and destructor have return type @void@, and the first parameter is a reference to the object type to be constructed or destructed.
 While the first parameter is informally called the @this@ parameter, as in object-oriented languages, any variable name may be used.
-Both constructors and destructors allow additional parametes after the @this@ parameter for specifying values for initialization/de-initialization\footnote{
+Both constructors and destructors allow additional parameters after the @this@ parameter for specifying values for initialization/de-initialization\footnote{
 Destruction parameters are useful for specifying storage-management actions, such as de-initialize but not deallocate.}.
 \begin{cfa}
@@ -2003,6 +2004,6 @@
 void ^?{}( VLA & vla ) with ( vla ) { free( data ); } $\C{// destructor}$
 {
-	VLA x;									$\C{// implicit:  ?\{\}( x );}$
-} 											$\C{// implicit:  ?\^{}\{\}( x );}$
+	VLA x;									$\C{// implicit:\ \ x\{\};}$
+} 											$\C{// implicit:\ \textasciicircum{}x\{\};}$
 \end{cfa}
 @VLA@ is a \newterm{managed type}\footnote{
@@ -2029,11 +2030,11 @@
 appropriate care is taken to not recursively call the copy constructor when initializing the second parameter.
 
-\CFA constructors may be explicitly call, like Java, and destructors may be explicitly called, like \CC.
+\CFA constructors may be explicitly called, like Java, and destructors may be explicitly called, like \CC.
 Explicit calls to constructors double as a \CC-style \emph{placement syntax}, useful for construction of member fields in user-defined constructors and reuse of existing storage allocations.
-While existing call syntax works for explicit calls to constructors and destructors, \CFA also provides a more concise \newterm{operator syntax} for both:
+Like the other operators in \CFA, there is a concise syntax for constructor/destructor function calls:
 \begin{cfa}
 {
 	VLA  x,            y = { 20, 0x01 },     z = y;	$\C{// z points to y}$
-	//      ?{}( x );   ?{}( y, 20, 0x01 );   ?{}( z, y ); 
+	//    x{};         y{ 20, 0x01 };          z{ z, y }; 
 	^x{};									$\C{// deallocate x}$
 	x{};									$\C{// reallocate x}$
@@ -2042,5 +2043,5 @@
 	y{ x };									$\C{// reallocate y, points to x}$
 	x{};									$\C{// reallocate x, not pointing to y}$
-	// ^?{}(z);  ^?{}(y);  ^?{}(x);
+	//  ^z{};  ^y{};  ^x{};
 }
 \end{cfa}
@@ -2063,5 +2064,5 @@
 In these cases, \CFA provides the initialization syntax \lstinline|S x `@=` {}|, and the object becomes unmanaged, so implicit constructor and destructor calls are not generated. 
 Any C initializer can be the right-hand side of an \lstinline|@=| initializer, \eg \lstinline|VLA a @= { 0, 0x0 }|, with the usual C initialization semantics.
-The same syntax can be used in a compound literal, \eg \lstinline|a = VLA`@`{ 0, 0x0 }|, to create a C-style literal.
+The same syntax can be used in a compound literal, \eg \lstinline|a = (VLA)`@`{ 0, 0x0 }|, to create a C-style literal.
 The point of \lstinline|@=| is to provide a migration path from legacy C code to \CFA, by providing a mechanism to incrementally convert to implicit initialization.
 
@@ -2119,5 +2120,5 @@
 
 In C, @0@ has the special property that it is the only ``false'' value;
-from the standard, any value that compares equal to @0@ is false, while any value that compares unequal to @0@ is true. 
+by the standard, any value that compares equal to @0@ is false, while any value that compares unequal to @0@ is true. 
 As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to @&&@, @||@, or @?:@\,) can be rewritten as @x != 0@ without changing its semantics.
 Operator overloading in \CFA provides a natural means to implement this truth-value comparison for arbitrary types, but the C type system is not precise enough to distinguish an equality comparison with @0@ from an equality comparison with an arbitrary integer or pointer. 
@@ -2154,5 +2155,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{postfix function}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{constant}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{variable/expression}}	& \multicolumn{1}{c}{\textbf{postfix pointer}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{postfix function}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{constant}}	& \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{variable/expression}}	& \multicolumn{1}{c@{}}{\textbf{postfix pointer}}	\\
 \begin{cfa}
 int |?`h|( int s );
@@ -2199,6 +2200,6 @@
 \lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{\CC}}	\\
+\begin{tabular}{@{}l@{\hspace{1.25\parindentlnth}}l@{}}
+\multicolumn{1}{@{}c@{\hspace{1.25\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{\CC}}	\\
 \begin{cfa}
 struct W {
@@ -2274,5 +2275,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}	& \multicolumn{1}{c}{\textbf{Usage}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}	& \multicolumn{1}{c@{}}{\textbf{Usage}}	\\
 \begin{cfa}
 const short int `MIN` = -32768;
@@ -2293,5 +2294,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 MIN
@@ -2319,5 +2320,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}	& \multicolumn{1}{c}{\textbf{Usage}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}	& \multicolumn{1}{c@{}}{\textbf{Usage}}	\\
 \begin{cfa}
 float `log`( float x );
@@ -2338,5 +2339,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 log
@@ -2366,5 +2367,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}	& \multicolumn{1}{c}{\textbf{Usage}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{Definition}}	& \multicolumn{1}{c@{}}{\textbf{Usage}}	\\
 \begin{cfa}
 unsigned int `abs`( int );
@@ -2385,5 +2386,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 abs
@@ -2408,5 +2409,5 @@
 an allocation with a specified character.
 \item[resize]
-an existing allocation to decreased or increased its size.
+an existing allocation to decrease or increase its size.
 In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
 For an increase in storage size, new storage after the copied data may be filled.
@@ -2447,6 +2448,5 @@
 \begin{figure}
 \centering
-\begin{cquote}
-\begin{cfa}[aboveskip=0pt]
+\begin{cfa}[aboveskip=0pt,xleftmargin=0pt]
 size_t  dim = 10;							$\C{// array dimension}$
 char fill = '\xff';							$\C{// initialization fill value}$
@@ -2454,7 +2454,7 @@
 \end{cfa}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{C}}	\\
-\begin{cfa}
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{@{}c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
+\begin{cfa}[xleftmargin=-10pt]
 ip = alloc();
 ip = alloc( fill );
@@ -2471,19 +2471,18 @@
 &
 \begin{cfa}
-ip = (int *)malloc( sizeof( int ) );
-ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, sizeof( int ) );
-ip = (int *)malloc( dim * sizeof( int ) );
-ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
-ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
-ip = (int *)realloc( ip, 4 * dim * sizeof( int ) );
-			memset( ip, fill, 4 * dim * sizeof( int ) );
-ip = memalign( 16, sizeof( int ) );
-ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
-ip = memalign( 16, dim * sizeof( int ) );
-ip = memalign( 16, dim * sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
-\end{cfa}
-\end{tabular}
-\lstMakeShortInline@%
-\end{cquote}
+ip = (int *)malloc( sizeof(int) );
+ip = (int *)malloc( sizeof(int) ); memset( ip, fill, sizeof(int) );
+ip = (int *)malloc( dim * sizeof(int) );
+ip = (int *)malloc( sizeof(int) ); memset( ip, fill, dim * sizeof(int) );
+ip = (int *)realloc( ip, 2 * dim * sizeof(int) );
+ip = (int *)realloc( ip, 4 * dim * sizeof(int) ); memset( ip, fill, 4 * dim * sizeof(int));
+
+ip = memalign( 16, sizeof(int) );
+ip = memalign( 16, sizeof(int) ); memset( ip, fill, sizeof(int) );
+ip = memalign( 16, dim * sizeof(int) );
+ip = memalign( 16, dim * sizeof(int) ); memset( ip, fill, dim * sizeof(int) );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
 \caption{\CFA versus C Storage-Allocation}
 \label{f:StorageAllocation}
@@ -2498,5 +2497,5 @@
 S * as = anew( dim, 2, 3 );					$\C{// each array element initialized to 2, 3}$
 \end{cfa}
-Note, \CC can only initialization array elements via the default constructor.
+Note, \CC can only initialize array elements via the default constructor.
 
 Finally, the \CFA memory-allocator has \newterm{sticky properties} for dynamic storage: fill and alignment are remembered with an object's storage in the heap.
@@ -2515,5 +2514,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{\CC}}	\\
+\multicolumn{1}{@{}c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{\CC}}	\\
 \begin{cfa}
 int x = 1, y = 2, z = 3;
@@ -2604,6 +2603,6 @@
 \centering
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}@{\hspace{2\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{@{\hspace{2\parindentlnth}}c}{\textbf{C}}	\\
+\begin{tabular}{@{}l@{\hspace{3\parindentlnth}}l@{}}
+\multicolumn{1}{@{}c@{\hspace{3\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c@{}}{\textbf{C}}	\\
 \begin{cfa}
 #include <gmp>
@@ -2638,5 +2637,5 @@
 
 
-\section{Polymorphic Evaluation}
+\section{Polymorphism Evaluation}
 \label{sec:eval}
 
@@ -2727,10 +2726,10 @@
 Line-count is a fairly rough measure of code complexity;
 another important factor is how much type information the programmer must specify manually, especially where that information is not compiler-checked.
-Such unchecked type information produces a heavier documentation burden and increased potential for runtime bugs, and is much less common in \CFA than C, with its manually specified function pointer arguments and format codes, or \CCV, with its extensive use of untype-checked downcasts, \eg @object@ to @integer@ when popping a stack.
+Such unchecked type information produces a heavier documentation burden and increased potential for runtime bugs, and is much less common in \CFA than C, with its manually specified function pointer arguments and format codes, or \CCV, with its extensive use of un-type-checked downcasts, \eg @object@ to @integer@ when popping a stack.
 To quantify this manual typing, the ``redundant type annotations'' line in Table~\ref{tab:eval} counts the number of lines on which the type of a known variable is respecified, either as a format specifier, explicit downcast, type-specific function, or by name in a @sizeof@, struct literal, or @new@ expression.
 The \CC benchmark uses two redundant type annotations to create a new stack nodes, while the C and \CCV benchmarks have several such annotations spread throughout their code.
 The \CFA benchmark is able to eliminate all redundant type annotations through use of the polymorphic @alloc@ function discussed in Section~\ref{sec:libraries}.
 
-We conjecture these results scale across most generic data-types as the underlying polymorphic implement is constant.
+We conjecture these results scale across most generic data-types as the underlying polymorphism implement is constant.
 
 
