Index: doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal-matmul.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal-matmul.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal-matmul.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -4,10 +4,10 @@
 forall( [M], [N], [P] )
 void matmul( array(float, M, P) & src1,
-             array(float, P, N) & src2, 
-             array(float, M, N) & tgt ) {
-    for (i; M) for (j; N) {
-        tgt[i][j] = 0;
-        for (k; P)
-            tgt[i][j] += src1[i][k] * src2[k][j];
-    }
+			 array(float, P, N) & src2, 
+			 array(float, M, N) & tgt ) {
+	for (i; M) for (j; N) {
+		tgt[i][j] = 0;
+		for (k; P)
+			tgt[i][j] += src1[i][k] * src2[k][j];
+	}
 }
Index: doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal-stdvec.cpp
===================================================================
--- doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal-stdvec.cpp	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal-stdvec.cpp	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -3,11 +3,11 @@
 forall( [M], [N], [P] )
 void matmul( array(float, M, P) & src1,
-             array(float, P, N) & src2, 
-             array(float, M, N) & tgt ) {
-    for (i; M) for (j; N) {
-        tgt[i][j] = 0;
-        for (k; P)
-            tgt[i][j] += src1[i][k] * src2[k][j];
-    }
+			 array(float, P, N) & src2, 
+			 array(float, M, N) & tgt ) {
+	for (i; M) for (j; N) {
+		tgt[i][j] = 0;
+		for (k; P)
+			tgt[i][j] += src1[i][k] * src2[k][j];
+	}
 }
 */
@@ -30,10 +30,10 @@
 
 float f( vector<float> & a ) {
-    float result = 0;
-    for( int i = 0; i < BOUND(a.size()); i++ ) {
-        result += a.at(i);
-        // hillarious that, while writing THIS VERY DEMO, on first go, I actaully wrote it a[i]
-    }
-    return result;
+	float result = 0;
+	for( int i = 0; i < BOUND(a.size()); i++ ) {
+		result += a.at(i);
+		// hillarious that, while writing THIS VERY DEMO, on first go, I actaully wrote it a[i]
+	}
+	return result;
 }
 
@@ -41,14 +41,14 @@
 #include <iostream>
 int main( int argc, char ** argv ) {
-    vector<float> v(5);
-    v.at(0) = 3.14;
-    v.at(1) = 3.14;
-    v.at(2) = 3.14;
-    v.at(3) = 3.14;
-    v.at(4) = 3.14;
+	vector<float> v(5);
+	v.at(0) = 3.14;
+	v.at(1) = 3.14;
+	v.at(2) = 3.14;
+	v.at(3) = 3.14;
+	v.at(4) = 3.14;
 
-    float answer = f(v);
+	float answer = f(v);
 
-    cout << "answer: " << answer << endl;
+	cout << "answer: " << answer << endl;
 
 }
@@ -80,18 +80,18 @@
 
 void matmul( mat & a, mat & b, mat & rslt ) {
-    size_t m = rslt.size();
-    assert( m == a.size() );
-    size_t p = b.size();
-    for ( int i = 0; i < BOUND(m); i++ ) {
-        assert( p == a.at(i).size() );
-        size_t n = rslt.at(i).size();
-        for ( int j = 0; j < BOUND(n); j++ ) {
-            rslt.at(i).at(j) = 0.0;
-            for ( int k = 0; k < BOUND(p); k++ ) {
-                assert(b.at(k).size() == n); // asking to check it too often
-                rslt.at(i).at(j) += a.at(i).at(k) * b.at(k).at(j);
-            }
-        }
-    }
+	size_t m = rslt.size();
+	assert( m == a.size() );
+	size_t p = b.size();
+	for ( int i = 0; i < BOUND(m); i++ ) {
+		assert( p == a.at(i).size() );
+		size_t n = rslt.at(i).size();
+		for ( int j = 0; j < BOUND(n); j++ ) {
+			rslt.at(i).at(j) = 0.0;
+			for ( int k = 0; k < BOUND(p); k++ ) {
+				assert(b.at(k).size() == n); // asking to check it too often
+				rslt.at(i).at(j) += a.at(i).at(k) * b.at(k).at(j);
+			}
+		}
+	}
 }
 
@@ -99,8 +99,8 @@
 #include <iostream>
 int main( int argc, char ** argv ) {
-    mat a(5, vector<float>(6));
-    mat b(6, vector<float>(7));
-    mat r(5, vector<float>(7));
-    matmul(a, b, r);
+	mat a(5, vector<float>(6));
+	mat b(6, vector<float>(7));
+	mat r(5, vector<float>(7));
+	matmul(a, b, r);
 }
 #endif 
Index: doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/array-boundcheck-removal.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -9,9 +9,9 @@
 forall( [N] )
 size_t foo( array( size_t, N ) & a ) {
-    size_t retval = 0;
-    for( i; N ) {
-        retval += a[i];
-    }
-    return retval;
+	size_t retval = 0;
+	for( i; N ) {
+		retval += a[i];
+	}
+	return retval;
 }
 
@@ -20,9 +20,9 @@
 forall( [N], [M] )
 size_t foo( array( size_t, N, M ) & a ) {
-    size_t retval = 0;
-    for( i; N ) for( j; M ) {
-        retval += a[i][j];
-    }
-    return retval;
+	size_t retval = 0;
+	for( i; N ) for( j; M ) {
+		retval += a[i][j];
+	}
+	return retval;
 }
 
@@ -31,9 +31,9 @@
 forall( [N] )
 size_t foo( array( size_t, N ) & a, array( size_t, N ) & b ) {
-    size_t retval = 0;
-    for( i; N ) {
-        retval += a[i] - b[i];
-    }
-    return retval;
+	size_t retval = 0;
+	for( i; N ) {
+		retval += a[i] - b[i];
+	}
+	return retval;
 }
 
@@ -42,11 +42,11 @@
 forall( [M], [N], [P] )
 void foo   ( array(size_t, M, P) & src1,
-             array(size_t, P, N) & src2, 
-             array(size_t, M, N) & tgt ) {
-    for (i; M) for (j; N) {
-        tgt[i][j] = 0;
-        for (k; P)
-            tgt[i][j] += src1[i][k] * src2[k][j];
-    }
+			 array(size_t, P, N) & src2, 
+			 array(size_t, M, N) & tgt ) {
+	for (i; M) for (j; N) {
+		tgt[i][j] = 0;
+		for (k; P)
+			tgt[i][j] += src1[i][k] * src2[k][j];
+	}
 }
 
Index: doc/theses/mike_brooks_MMath/programs/bkgd-carray-arrty.c
===================================================================
--- doc/theses/mike_brooks_MMath/programs/bkgd-carray-arrty.c	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/bkgd-carray-arrty.c	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -150,4 +150,4 @@
 
 // Local Variables: //
-// compile-command: "sed -f sedcmd bkgd-carray-arrty.c > tmp.c; gcc tmp.c" //
+// compile-command: "sed -f sedcmd bkgd-carray-arrty.c | gcc -c -x c -" //
 // End: //
Index: doc/theses/mike_brooks_MMath/programs/bkgd-carray-decay.c
===================================================================
--- doc/theses/mike_brooks_MMath/programs/bkgd-carray-decay.c	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/bkgd-carray-decay.c	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -18,15 +18,15 @@
 	// reusing local var `float a[10];`}
 	float v;
-	f(  a,  a ); $\C{// ok: two decays, one into an array spelling}$
-	f( &v, &v ); $\C{// ok: no decays; a non-array passes to an array spelling}$
+	f( a, a );					$\C{// ok: two decays, one into an array spelling}$
+	f( &v, &v );				$\C{// ok: no decays; a non-array passes to an array spelling}$
 
-	char ca[] = "hello";    $\C{// array on stack, initialized from read-only data}$
-	char *cp = "hello";     $\C{// pointer to read-only data [decay here]}$
-	void edit(char c[]) {   $\C{// param is pointer}$
+	char ca[] = "hello";		$\C{// array on stack, initialized from read-only data}$
+	char *cp = "hello";			$\C{// pointer to read-only data [decay here]}$
+	void edit( char c[] ) {		$\C{// param is pointer}$
 		c[3] = 'p';
 	}
-	edit(ca);               $\C{// ok [decay here]}$
-	edit(cp);               $\C{// Segmentation fault}$
-	edit("hello");          $\C{// Segmentation fault [decay here]}$
+	edit( ca );					$\C{// ok [decay here]}$
+	edit( c p );				$\C{// Segmentation fault}$
+	edit( "hello" );			$\C{// Segmentation fault [decay here]}$
 
 	void decay( float x[10] ) {
Index: doc/theses/mike_brooks_MMath/programs/bkgd-carray-mdim.c
===================================================================
--- doc/theses/mike_brooks_MMath/programs/bkgd-carray-mdim.c	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/bkgd-carray-mdim.c	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -14,43 +14,33 @@
 
 int main() {
+	float a[3][10];
+	static_assert(sizeof(float)==4);			$\C{// floats (atomic elements) are 4 bytes}$
+	static_assert(sizeof(void*)==8);			$\C{// pointers are 8 bytes}$
 
-/*
-As in the last section, we inspect the declaration ...
-*/
-    float a[3][10];
-/*
+	static_assert(sizeof( a ) == 120);			$\C{// the array, float[3][10]}$
+	static_assert(sizeof( a[0] ) == 40);		$\C{// its first element, float[10]}$
+	static_assert(sizeof( a[0][0] ) == 4 );		$\C{// its first grand element, float}$
 
-*/
-    static_assert(sizeof(float)==4);    // floats (atomic elements) are 4 bytes
-    static_assert(sizeof(void*)==8);    // pointers are 8 bytes
-/*
+	static_assert(sizeof(&(a)) == 8);			$\C{// pointer to the array, float(*)[3][10]}$
+	static_assert(sizeof(&(a[0])) == 8  );		$\C{// pointer to its first element, float(*)[10]}$
+	static_assert(sizeof(&(a[0][0])) == 8  );	$\C{// pointer to its first grand-element, float*}$
 
-The significant axis of deriving expressions from @a@ is now ``itself,'' ``first element'' or ``first grand-element (meaning, first element of first element).''
-*/
-    static_assert(sizeof(  a       ) == 120); // the array, float[3][10]
-    static_assert(sizeof(  a[0]    ) == 40 ); // its first element, float[10]
-    static_assert(sizeof(  a[0][0] ) == 4  ); // its first grand element, float
+	float (*pa  )[3][10] = &(a	  );
+	float (*pa0 )   [10] = &(a[0]   );
+	float  *pa00		 = &(a[0][0]);
 
-    static_assert(sizeof(&(a      )) == 8  ); // pointer to the array, float(*)[3][10]
-    static_assert(sizeof(&(a[0]   )) == 8  ); // pointer to its first element, float(*)[10]
-    static_assert(sizeof(&(a[0][0])) == 8  ); // pointer to its first grand-element, float*
+	static_assert((void*)&a == (void*)&(a[0]   ));
+	static_assert((void*)&a == (void*)&(a[0][0]));
 
-    float (*pa  )[3][10] = &(a      );
-    float (*pa0 )   [10] = &(a[0]   );
-    float  *pa00         = &(a[0][0]);
+	assert( (void *) pa == (void *) pa0  );
+	assert( (void *) pa == (void *) pa00 );
 
-    static_assert((void*)&a == (void*)&(a[0]   ));
-    static_assert((void*)&a == (void*)&(a[0][0]));
-
-    assert( (void *) pa == (void *) pa0  );
-    assert( (void *) pa == (void *) pa00 );
-
-//    float (*b[3])[10];
-    float *b[3];
-    for (int i = 0; i < 3; i ++) {
-        b[i] = malloc(sizeof(float[10]));
-    }
-    a[2][3];
-    b[2][3];
+//	float (*b[3])[10];
+	float *b[3];
+	for (int i = 0; i < 3; i ++) {
+		b[i] = malloc(sizeof(float[10]));
+	}
+	a[2][3];
+	b[2][3];
 /*
 
Index: doc/theses/mike_brooks_MMath/programs/bkgd-cfa-arrayinteract.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/bkgd-cfa-arrayinteract.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/bkgd-cfa-arrayinteract.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
Index: doc/theses/mike_brooks_MMath/programs/hello-accordion.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/hello-accordion.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/hello-accordion.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -11,8 +11,8 @@
 forall( T, [Nclients], [Ncosts] )
 struct request {
-    unsigned int requestor_id;
-    array( T, Nclients ) impacted_client_ids; // nested VLA
-    array( float, Ncosts ) cost_contribs; // nested VLA
-    float total_cost;
+	unsigned int requestor_id;
+	array( T, Nclients ) impacted_client_ids; // nested VLA
+	array( float, Ncosts ) cost_contribs; // nested VLA
+	float total_cost;
 };
 
@@ -41,9 +41,9 @@
 forall( T, [Nclients], [Ncosts] )
 void summarize( request( T, Nclients, Ncosts ) & r ) {
-    r.total_cost = 0;
-    for( i; Ncosts )
-        r.total_cost += r.cost_contribs[i];
-    // say the cost is per-client, to make output vary
-    r.total_cost *= Nclients;
+	r.total_cost = 0;
+	for( i; Ncosts )
+		r.total_cost += r.cost_contribs[i];
+	// say the cost is per-client, to make output vary
+	r.total_cost *= Nclients;
 }
 
Index: doc/theses/mike_brooks_MMath/programs/hello-array.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/hello-array.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/hello-array.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -10,9 +10,9 @@
 forall( [N] ) // array bound
 array(bool, N) & f( array(float, N) & a, array(float, N) & b ) {
-    array(bool, N) & ret = *alloc(); // sizeof used by alloc
-    for( i; N ) {
-        ret[i] = 0.005 > 2 * (abs(a[i] - b[i])) / (abs(a[i]) + abs(b[i]));
-    }
-    return ret;
+	array(bool, N) & ret = *alloc(); // sizeof used by alloc
+	for( i; N ) {
+		ret[i] = 0.005 > 2 * (abs(a[i] - b[i])) / (abs(a[i]) + abs(b[i]));
+	}
+	return ret;
 }
 
@@ -29,16 +29,16 @@
 
 int main( int argc, char * argv[] ) {
-    int n = ato( argv[1] );
-    array(float, n) a, b; // VLA
-    for ( i; n ) {
-        a[i] = 3.14 / (i + 1);
-        b[i] = a[i] + 0.005 ;
-    }
-    array(bool, n) & result = f( a, b ); // call
-    sout | "result: " | nonl;
-    for ( i; n )
-        sout | result[i] | nonl;
-    sout | nl;
-    free( &result ); // free returned storage
+	int n = ato( argv[1] );
+	array(float, n) a, b; // VLA
+	for ( i; n ) {
+		a[i] = 3.14 / (i + 1);
+		b[i] = a[i] + 0.005 ;
+	}
+	array(bool, n) & result = f( a, b ); // call
+	sout | "result: " | nonl;
+	for ( i; n )
+		sout | result[i] | nonl;
+	sout | nl;
+	free( &result ); // free returned storage
 }
 /*
@@ -52,7 +52,7 @@
 	array(float, 10) a;
 	array(float, 20) b;
-    f( a, a );
-    f( b, b );
-    f( a, b );
+	f( a, a );
+	f( b, b );
+	f( a, b );
 }
 
@@ -60,7 +60,7 @@
 forall( [M], [N] )
 void bad( array(float, M) &a, array(float, N) &b ) {
-    f( a, a ); // ok
-    f( b, b ); // ok
-    f( a, b ); // error
+	f( a, a ); // ok
+	f( b, b ); // ok
+	f( a, b ); // error
 }
 #endif
@@ -70,6 +70,6 @@
 forall( [M], [N] )
 void bad_fixed( array(float, M) & a, array(float, N) & b ) {
-    if ( M == N ) {
-        f( a, (array(float, M) &)b ); // cast b to matching type
-    }
+	if ( M == N ) {
+		f( a, (array(float, M) &)b ); // cast b to matching type
+	}
 }
Index: doc/theses/mike_brooks_MMath/programs/hello-md.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/hello-md.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/hello-md.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -60,8 +60,8 @@
 forall( [N] )
 void print1d_cstyle( array(float, N) & c ) {
-    for ( i; N ) {
-        sout | c[i] | nonl;
-    }
-    sout | nl;
+	for ( i; N ) {
+		sout | c[i] | nonl;
+	}
+	sout | nl;
 }
 
@@ -79,8 +79,8 @@
 forall( [N], C & | ar( C, float, N ) )
 void print1d( C & c ) {
-    for( i; N ) {
-        sout | c[i] | nonl;
-    }
-    sout | nl;
+	for( i; N ) {
+		sout | c[i] | nonl;
+	}
+	sout | nl;
 }
 
@@ -99,12 +99,12 @@
 
 void fill( array(float, 5, 7) & a ) {
-    for ( i; (ptrdiff_t) 5 ) {
-        for ( j; 7 ) {
-            a[i,j] = 1.0 * i + 0.1 * j;
-            sout | a[[i,j]] | nonl;
-        }
-        sout | nl;
-    }
-    sout | nl;
+	for ( i; (ptrdiff_t) 5 ) {
+		for ( j; 7 ) {
+			a[i,j] = 1.0 * i + 0.1 * j;
+			sout | a[[i,j]] | nonl;
+		}
+		sout | nl;
+	}
+	sout | nl;
 }
 
@@ -125,5 +125,5 @@
 4.0  4.1  4.2  4.3  4.4  4.5  4.6
 */
-    
+
 
 
Index: doc/theses/mike_brooks_MMath/programs/lst-features-intro.run.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-features-intro.run.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-features-intro.run.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -19,6 +19,6 @@
 
 struct req {
-  int pri, rqr;
-  inline dlink(req);
+	int pri, rqr;
+	inline dlink(req);
 };
 
@@ -26,6 +26,6 @@
 
 req
-  r1 = {1, 42},
-  r2 = {2, 42};
+	r1 = {1, 42},
+	r2 = {2, 42};
 
 insert_first(reqs, r2);
@@ -51,5 +51,5 @@
 
 while( req & cur = reqs`elems; cur`moveNext )
-    printf("{%d %d} ", cur.pri, cur.rqr);
+	printf("{%d %d} ", cur.pri, cur.rqr);
 printf("\n");
 
Index: doc/theses/mike_brooks_MMath/programs/lst-features-multidir.run.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-features-multidir.run.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-features-multidir.run.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -19,7 +19,7 @@
 
 struct req {
-  int pri, rqr;
-  inline struct by_pri { inline dlink(req); };
-  inline struct by_rqr { inline dlink(req); };
+	int pri, rqr;
+	inline struct by_pri { inline dlink(req); };
+	inline struct by_rqr { inline dlink(req); };
 };
 
@@ -44,10 +44,10 @@
 
 struct req
-  r42a = {1, 42},
-  r42b = {2, 42},
-  r17a = {2, 17},
-  r17b = {3, 17},
-  r17c = {4, 17},
-  r99a = {3, 99};
+	r42a = {1, 42},
+	r42b = {2, 42},
+	r17a = {2, 17},
+	r17b = {3, 17},
+	r17c = {4, 17},
+	r99a = {3, 99};
 
 insert_first(reqs_pri_global, r17c);
@@ -75,19 +75,19 @@
 
 with(DLINK_VIA(req, req.by_pri)) {
-    while( req & cur = reqs_pri_global`elems; cur`moveNext )
-        printf("{%d %d} ", cur.pri, cur.rqr);
-    printf("| ");
+	while( req & cur = reqs_pri_global`elems; cur`moveNext )
+		printf("{%d %d} ", cur.pri, cur.rqr);
+	printf("| ");
 }
 
 with(DLINK_VIA(req, req.by_rqr)) {
-    while( req & cur = reqs_rqr_42`elems; cur`moveNext )
-        printf("{%d %d} ", cur.pri, cur.rqr);
-    printf("| ");
-    while( req & cur = reqs_rqr_17`elems; cur`moveNext )
-        printf("{%d %d} ", cur.pri, cur.rqr);
-    printf("| ");
-    while( req & cur = reqs_rqr_99`elems; cur`moveNext )
-        printf("{%d %d} ", cur.pri, cur.rqr);
-    printf("\n");
+	while( req & cur = reqs_rqr_42`elems; cur`moveNext )
+		printf("{%d %d} ", cur.pri, cur.rqr);
+	printf("| ");
+	while( req & cur = reqs_rqr_17`elems; cur`moveNext )
+		printf("{%d %d} ", cur.pri, cur.rqr);
+	printf("| ");
+	while( req & cur = reqs_rqr_99`elems; cur`moveNext )
+		printf("{%d %d} ", cur.pri, cur.rqr);
+	printf("\n");
 }
 
Index: doc/theses/mike_brooks_MMath/programs/lst-issues-attach-reduction.hpp
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-issues-attach-reduction.hpp	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-issues-attach-reduction.hpp	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -100,20 +100,20 @@
 template<typename El>
 class list {
-    struct node {
-        LIST_ENTRY(node) links;
-        El elem;
-    };
-    LIST_HEAD(Impl, node);
-    Impl impl;
+	struct node {
+		LIST_ENTRY(node) links;
+		El elem;
+	};
+	LIST_HEAD(Impl, node);
+	Impl impl;
   public:
-    list() {
-        LIST_INIT(&impl);
-    }
-    void push_front( const El & src ) {
-        node * n = new node();
-        n->elem = src;
-        LIST_INSERT_HEAD(&impl, n, links);
-    }
-    // ... `emplace` elided
+	list() {
+		LIST_INIT(&impl);
+	}
+	void push_front( const El & src ) {
+		node * n = new node();
+		n->elem = src;
+		LIST_INSERT_HEAD(&impl, n, links);
+	}
+	// ... `emplace` elided
 
 
@@ -129,19 +129,19 @@
 
 
-    template<typename... CtorArgs>
-    void emplace_front( CtorArgs... args ) {  
-        El tempEl{args...}; // (mock: avoid real emplacing to keep `struct node` simple; disucssion is about allocation, not copying)
-        push_front(tempEl);
-    }
-    class IType {
-        node* p;
-      public:
-        IType(node* p) : p(p) {}
-        bool operator!=(IType rhs) {return p != rhs.p;}
-        const El& operator*() {return p->elem;}
-        void operator++() { p = LIST_NEXT(p, links); }
-    };
-    IType begin() {return IType(LIST_FIRST(&impl)); }
-    IType end() {return IType(NULL); }
+	template<typename... CtorArgs>
+	void emplace_front( CtorArgs... args ) {  
+		El tempEl{args...}; // (mock: avoid real emplacing to keep `struct node` simple; disucssion is about allocation, not copying)
+		push_front(tempEl);
+	}
+	class IType {
+		node* p;
+	  public:
+		IType(node* p) : p(p) {}
+		bool operator!=(IType rhs) {return p != rhs.p;}
+		const El& operator*() {return p->elem;}
+		void operator++() { p = LIST_NEXT(p, links); }
+	};
+	IType begin() {return IType(LIST_FIRST(&impl)); }
+	IType end() {return IType(NULL); }
 
 
Index: doc/theses/mike_brooks_MMath/programs/lst-issues-intrusive.run.c
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-issues-intrusive.run.c	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-issues-intrusive.run.c	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -21,6 +21,6 @@
 
 struct req {
-  int pri, rqr;
-  LIST_ENTRY(req) x;
+	int pri, rqr;
+	LIST_ENTRY(req) x;
 };
 
@@ -31,11 +31,11 @@
 
 struct req
-  r1 = {1, 42},
-  r2 = {2, 42};
+	r1 = {1, 42},
+	r2 = {2, 42};
 
 LIST_INSERT_HEAD(
-  &reqs, &r2, x);
+	&reqs, &r2, x);
 LIST_INSERT_HEAD(
-  &reqs, &r1, x);
+	&reqs, &r1, x);
 
 
@@ -51,5 +51,5 @@
 struct req *cur;
 LIST_FOREACH(cur, &reqs, x)
-    printf("{%d %d} ", cur->pri, cur->rqr);
+	printf("{%d %d} ", cur->pri, cur->rqr);
 printf("\n");
 
Index: doc/theses/mike_brooks_MMath/programs/lst-issues-multi-static.run.c
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-issues-multi-static.run.c	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-issues-multi-static.run.c	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -19,7 +19,7 @@
 
 struct req {
-  int pri, rqr;
-  LIST_ENTRY(req) by_pri;
-  LIST_ENTRY(req) by_rqr;
+	int pri, rqr;
+	LIST_ENTRY(req) by_pri;
+	LIST_ENTRY(req) by_rqr;
 };
 
@@ -37,10 +37,10 @@
 
 struct req
-  r42a = {1, 42},
-  r42b = {2, 42},
-  r17a = {2, 17},
-  r17b = {3, 17},
-  r17c = {4, 17},
-  r99a = {3, 99};
+	r42a = {1, 42},
+	r42b = {2, 42},
+	r17a = {2, 17},
+	r17b = {3, 17},
+	r17c = {4, 17},
+	r99a = {3, 99};
 
 LIST_INSERT_HEAD(&reqs_pri_global, &r17c, by_pri);
@@ -68,14 +68,14 @@
 struct req *cur;
 LIST_FOREACH(cur, &reqs_pri_global, by_pri)
-    printf("{%d %d} ", cur->pri, cur->rqr);
+	printf("{%d %d} ", cur->pri, cur->rqr);
 printf("| ");
 LIST_FOREACH(cur, &reqs_rqr_42, by_rqr)
-    printf("{%d %d} ", cur->pri, cur->rqr);
+	printf("{%d %d} ", cur->pri, cur->rqr);
 printf("| ");
 LIST_FOREACH(cur, &reqs_rqr_17, by_rqr)
-    printf("{%d %d} ", cur->pri, cur->rqr);
+	printf("{%d %d} ", cur->pri, cur->rqr);
 printf("| ");
 LIST_FOREACH(cur, &reqs_rqr_99, by_rqr)
-    printf("{%d %d} ", cur->pri, cur->rqr);
+	printf("{%d %d} ", cur->pri, cur->rqr);
 printf("\n");
 
Index: doc/theses/mike_brooks_MMath/programs/lst-issues-wrapped-byref.run.cpp
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-issues-wrapped-byref.run.cpp	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-issues-wrapped-byref.run.cpp	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -21,5 +21,5 @@
 
 struct req {
-  int pri, rqr;
+	int pri, rqr;
 };
 
@@ -31,11 +31,11 @@
 
 req
-  r1 = {1, 42},
-  r2 = {2, 42};
+	r1 = {1, 42},
+	r2 = {2, 42};
 
 reqs.push_front(
-  &r2);
+	&r2);
 reqs.push_front(
-  &r1);
+	&r1);
 
 
@@ -53,5 +53,5 @@
 
 for (auto const& cur : reqs)
-    printf("{%d %d} ", cur->pri, cur->rqr);
+	printf("{%d %d} ", cur->pri, cur->rqr);
 printf("\n");
 
Index: doc/theses/mike_brooks_MMath/programs/lst-issues-wrapped-emplaced.run.cpp
===================================================================
--- doc/theses/mike_brooks_MMath/programs/lst-issues-wrapped-emplaced.run.cpp	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/lst-issues-wrapped-emplaced.run.cpp	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -21,5 +21,5 @@
 
 struct req {
-  int pri, rqr;
+	int pri, rqr;
 };
 
@@ -35,7 +35,7 @@
 
 reqs.emplace_front(
-  2, 42);
+	2, 42);
 reqs.emplace_front(
-  1, 42);
+	1, 42);
 
 
@@ -53,5 +53,5 @@
 
 for (auto const& cur : reqs)
-    printf("{%d %d} ", cur.pri, cur.rqr);
+	printf("{%d %d} ", cur.pri, cur.rqr);
 printf("\n");
 
Index: doc/theses/mike_brooks_MMath/programs/sharectx-demo.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/sharectx-demo.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/sharectx-demo.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -19,17 +19,17 @@
 
 void helper2() {
-   c();
-   string_sharectx c = {NEW_SHARING};
-   d();
+	c();
+	string_sharectx c = {NEW_SHARING};
+	d();
 }
 void helper1() {
-   a();
-   string_sharectx c = {NO_SHARING};
-   b();
-   helper2();
-   e();
+	a();
+	string_sharectx c = {NO_SHARING};
+	b();
+	helper2();
+	e();
 }
 int main() {
-   helper1();
+	helper1();
 }
 
Index: doc/theses/mike_brooks_MMath/programs/sharing-demo.cfa
===================================================================
--- doc/theses/mike_brooks_MMath/programs/sharing-demo.cfa	(revision b64d0f4af1fe5b3c45967f89591e4e709fe89116)
+++ doc/theses/mike_brooks_MMath/programs/sharing-demo.cfa	(revision 5546f50bf35c5f4954710cc34931ca3a077bf641)
@@ -37,10 +37,10 @@
 	assert( s1 == "a+c" );
 	sout | xstr(S1s1) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-      
+
 	#define S1As1 s1a[1] = '-'
 	S1As1;
 	assert( s1a == "a-c" );
 	sout | xstr(S1As1) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-      
+
 	#define S2s1 s2 [1] = '|'
 	S2s1;
@@ -49,5 +49,5 @@
 	sout | "\\end{tabular}";
 	sout | "\\par\\noindent";
-      
+
 	sout | "Assignment of a value is just a modificiation."
 		   "\nThe aliasing relationship is established at construction and is unaffected by assignment of a value.";
@@ -61,10 +61,10 @@
 	assert( s1 == "qrs" );
 	sout | xstr(S1qrs) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-    
+
 	#define S1Atuv s1a = "tuv"
 	S1Atuv;
 	assert( s1a == "tuv" );
 	sout | xstr(S1Atuv) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-    
+
 	#define S2wxy s2  = "wxy"
 	S2wxy;
@@ -87,5 +87,5 @@
 	assert( s2 == "wxy" );
 	sout | xstr(S1S2) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-    
+
 	#define S1aaa s1  = "aaa"
 	S1aaa;
@@ -94,5 +94,5 @@
 	assert( s2 == "wxy" );
 	sout | xstr(S1aaa) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-    
+
 	#define S2S1 s2  = s1
 	S2S1;
@@ -101,5 +101,5 @@
 	assert( s2 == "aaa" );
 	sout | xstr(S2S1) | "\t& " | s1 | "\t& " | s1a | "\t& " | s2 | "\t\\\\";
-    
+
 	#define S2bbb s2  = "bbb"
 	S2bbb;
@@ -191,5 +191,5 @@
 	sout | "\t\t\t\t& @s1@\t& @s1_mid@\t& @s2@\t\\\\";
 	sout | "\t& " | s1 | "\t& " | s1_mid | "\t& " | s2 | "\t\\\\";
-    
+
 	#define D2_s1mid_ff s1_mid = "ff"
 	D2_s1mid_ff;
@@ -207,5 +207,5 @@
 	sout | "\\end{tabular}";
 	sout | "\\par\\noindent";
-    
+
     sout | "In the \\emph{ff} step, which is a positive example of flow across an aliasing relationship, the result is straightforward to accept because the flow direction is from contained (small) to containing (large).  The following rules for edits through aliasing substrings will guide how to flow in the opposite direction.";
 	sout | "\\par";
@@ -233,5 +233,5 @@
 	assert( s1_mid == "i" );
 	sout  | xstr(D2_s1mid_i)  | "\t& " | s1 | "\t& " | s1_mid | "\t\\\\";
-    
+
 	#define D2_s1mid_empty s1_mid = ""
 	D2_s1mid_empty;
@@ -247,5 +247,5 @@
 	sout | "\\end{tabular}";
 	sout | "\\par\\noindent";
-    
+
     sout | "Multiple portions can be aliased.  When there are several aliasing substrings at once, the text editor analogy becomes an online multi-user editor.  I should be able to edit a paragraph in one place (changing the document's length), without my edits affecting which letters are within a mouse-selection that you had made previously, somewhere else.";
 	sout | "\\par\\noindent";
@@ -279,5 +279,5 @@
 	sout | "\\begin{tabular}{llllll}";
 	sout | "\t\t\t\t& @s1@\t& @s1_bgn@\t& @s1_crs@\t& @s1_mid@\t& @s1_end@\t\\\\";
-    
+
 	#define D2_s1crs_s1 string s1_crs = s1(3, 2)`shareEdits
 	D2_s1crs_s1;
@@ -288,5 +288,5 @@
 	assert( s1_end == "d" );  
 	sout  | xstr(D2_s1crs_s1)  | "\t& " | s1 | "\t& " | s1_bgn | "\t& " | s1_crs | "\t& " | s1_mid | "\t& " | s1_end | "\t\\\\";
-    
+
 	#define D2_s1crs_ppp s1_crs = "+++"
 	D2_s1crs_ppp;
@@ -316,5 +316,5 @@
 
 	// "The extreme form of this shortening happens when a bystander alias is a proper substring of an edit.  The bystander becomes an empty substring."
-    
+
 	string all = "They said hello again";
 	string greet     = all(10,5)`shareEdits;
@@ -327,5 +327,5 @@
 	assert( greet_end == "o" );
       
-    
+
 	greet = "sup";
 	assert( all == "They said sup again" );
@@ -334,5 +334,5 @@
 	// assert( greet_end == "" );
       
-    
+
   
 
@@ -342,5 +342,5 @@
 
   
-    
+
 	greet_bgn = "what"; 
       
@@ -353,5 +353,5 @@
 	// assert( greet_end == "" );    ------ Should be so, but fails
       
-    
+
 	greet_end = "..."; 
       
@@ -365,5 +365,5 @@
 	assert( greet_end == "..." );
       
-    
+