Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision c5ce0ecd56e67e949d0b059b405df1120ed18b85)
+++ doc/papers/general/Paper.tex	(revision 41624f920cc089ca5cfd4d561c8971bc2c474125)
@@ -671,6 +671,6 @@
 \begin{cfa}
 int f( int, int );
-int g( [int, int] );
-int h( int, [int, int] );
+[int] g( [int, int] );
+[int] h( int, [int, int] );
 [int, int] x;
 int y;
@@ -706,5 +706,5 @@
 This example shows mass, multiple, and cascading assignment used in one expression:
 \begin{cfa}
-void f( [int, int] );
+[void] f( [int, int] );
 f( [x, y] = z = 1.5 );						$\C{// assignments in parameter list}$
 \end{cfa}
@@ -814,5 +814,5 @@
 Flattening and restructuring conversions are also applied to tuple types in polymorphic type assertions.
 \begin{cfa}
-int f( [int, double], double );
+[int] f( [int, double], double );
 forall( otype T, otype U | { T f( T, U, U ); } ) void g( T, U );
 g( 5, 10.21 );
@@ -1152,5 +1152,5 @@
   case 4:
 	... `fallthrough common;`
-  common: // below fallthrough at same level as case clauses
+  `common`: // below fallthrough at same level as case clauses
 	...	 // common code for cases 3 and 4
 	// implicit break
@@ -1857,7 +1857,7 @@
 \begin{cfa}
 struct S { double x, y; };
-int i, j;
+int x, y;
 void f( int & i, int & j, S & s, int v[] );
-f( 3, i + j, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } );	$\C{// pass rvalue to lvalue \(\Rightarrow\) implicit temporary}$
+f( 3, x + y, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } ); $\C{// pass rvalue to lvalue \(\Rightarrow\) implicit temporary}$
 \end{cfa}
 This allows complex values to be succinctly and efficiently passed to functions, without the syntactic overhead of explicit definition of a temporary variable or the runtime cost of pass-by-value.
@@ -1998,5 +1998,5 @@
 {
 	VLA  x,            y = { 20, 0x01 },     z = y;	$\C{// z points to y}$
-	//      ?{}( x );  ?{}( y, 20, 0x01 );  ?{}( z, y ); 
+	//    ?{}( x );   ?{}( y, 20, 0x01 );    ?{}( z, y ); 
 	^x{};									$\C{// deallocate x}$
 	x{};									$\C{// reallocate x}$