Index: doc/generic_types/Makefile
===================================================================
--- doc/generic_types/Makefile	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/Makefile	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -66,5 +66,5 @@
 ## Define the default recipes.
 
-${GRAPHS} : evaluation/timing.gp evaluation/timing.csv
+${GRAPHS} : evaluation/timing.gp evaluation/timing.dat
 	gnuplot evaluation/timing.gp
 
Index: doc/generic_types/evaluation/Makefile
===================================================================
--- doc/generic_types/evaluation/Makefile	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/Makefile	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -67,5 +67,5 @@
 	@/usr/bin/time -f 'max_memory:\t%M kilobytes' ./c-bench
 	@printf 'source_size:\t%8d lines\n' `cat $(CFILES) | wc -l`
-	@printf 'redundant_type_annotations:%8d count\n' `cat $(CFILES) | fgrep '/***/' -c`
+	@printf 'redundant_type_annotations:%8d lines\n' `cat $(CFILES) | fgrep '/***/' -c`
 	@printf 'binary_size:\t%8d bytes\n' `stat -c %s c-bench`
 
@@ -75,5 +75,5 @@
 	@/usr/bin/time -f 'max_memory:\t %M kilobytes' ./cfa-bench
 	@printf 'source_size:\t%8d lines\n' `cat $(CFAFILES) | wc -l`
-	@printf 'redundant_type_annotations:%8d count\n' `cat $(CFAFILES) | fgrep '/***/' -c`
+	@printf 'redundant_type_annotations:%8d lines\n' `cat $(CFAFILES) | fgrep '/***/' -c`
 	@printf 'binary_size:\t%8d bytes\n' `stat -c %s cfa-bench`
 
@@ -83,13 +83,13 @@
 	@/usr/bin/time -f 'max_memory:\t %M kilobytes' ./cpp-bench
 	@printf 'source_size:\t%8d lines\n' `cat $(CPPFILES) | wc -l`
-	@printf 'redundant_type_annotations:%8d count\n' `cat $(CPPFILES) | fgrep '/***/' -c`
+	@printf 'redundant_type_annotations:%8d lines\n' `cat $(CPPFILES) | fgrep '/***/' -c`
 	@printf 'binary_size:\t%8d bytes\n' `stat -c %s cpp-bench`
 
 run-cppv: cpp-vbench
 	@echo
-	@echo '## C++ virtual ##'
+	@echo '## C++obj ##'
 	@/usr/bin/time -f 'max_memory:\t%M kilobytes' ./cpp-vbench
 	@printf 'source_size:\t%8d lines\n' `cat $(CPPVFILES) | wc -l`
-	@printf 'redundant_type_annotations:%8d count\n' `cat $(CPPVFILES) | fgrep '/***/' -c`
+	@printf 'redundant_type_annotations:%8d lines\n' `cat $(CPPVFILES) | fgrep '/***/' -c`
 	@printf 'binary_size:\t%8d bytes\n' `stat -c %s cpp-vbench`
 
Index: doc/generic_types/evaluation/bench.h
===================================================================
--- doc/generic_types/evaluation/bench.h	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/bench.h	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,15 +1,9 @@
 #pragma once
-
 #include <stdio.h>
 #include <time.h>
 
-#ifndef N
+long ms_between(clock_t start, clock_t end) { return (end - start) / (CLOCKS_PER_SEC / 1000); }
+
 #define N 40000000
-#endif
-
-long ms_between(clock_t start, clock_t end) {
-	return (end - start) / (CLOCKS_PER_SEC / 1000);
-}
-
 #define TIMED(name, code) { \
 	volatile clock_t _start, _end; \
@@ -19,6 +13,4 @@
 	printf("%s:\t%8ld ms\n", name, ms_between(_start, _end)); \
 }
-
 #define REPEAT_N_TIMED(name, n, code) TIMED( name, for (int _i = 0; _i < n; ++_i) { code } )
-
 #define REPEAT_TIMED(name, code) REPEAT_N_TIMED(name, N, code)
Index: doc/generic_types/evaluation/bench.hpp
===================================================================
--- doc/generic_types/evaluation/bench.hpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/bench.hpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,16 +1,10 @@
 #pragma once
-
 #include <iomanip>
 #include <iostream>
 #include <time.h>
 
-#ifndef N
+long ms_between(clock_t start, clock_t end) { return (end - start) / (CLOCKS_PER_SEC / 1000); }
+
 static const int N = 40000000;
-#endif
-
-long ms_between(clock_t start, clock_t end) {
-	return (end - start) / (CLOCKS_PER_SEC / 1000);
-}
-
 #define TIMED(name, code) { \
 	volatile clock_t _start, _end; \
@@ -18,8 +12,7 @@
 	code \
 	_end = clock(); \
-	std::cout << name << ":\t" << std::setw(8) << ms_between(_start, _end) << std::setw(0) << " ms" << std::endl; \
+	std::cout << name << ":\t" << std::setw(8) << ms_between(_start, _end) \
+		<< std::setw(0) << " ms" << std::endl; \
 }
-
 #define REPEAT_N_TIMED(name, n, code) TIMED( name, for (int _i = 0; _i < n; ++_i) { code } )
-
 #define REPEAT_TIMED(name, code) REPEAT_N_TIMED(name, N, code)
Index: doc/generic_types/evaluation/c-bench.c
===================================================================
--- doc/generic_types/evaluation/c-bench.c	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/c-bench.c	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -25,15 +25,11 @@
 
 void* copy_bool( const void* p ) { return new_bool( *(const _Bool*)p ); } /***/
-
 void* copy_char( const void* p ) { return new_char( *(const char*)p ); } /***/
-
 void* copy_int( const void* p ) { return new_int( *(const int*)p ); } /***/
-
 void* copy_pair_bool_char( const void* p ) { return copy_pair( p, copy_bool, copy_char ); } /***/
-
 void free_pair_bool_char( void* p ) { free_pair( p, free, free ); } /***/
 
-int cmp_bool( const void* a, const void* b ) {
-	return *(const _Bool*)a == *(const _Bool*)b ? 0 : *(const _Bool*)a < *(const _Bool*)b ? -1 : 1; /***/
+int cmp_bool( const void* a, const void* b ) { /***/
+	return *(const _Bool*)a == *(const _Bool*)b ? 0 : *(const _Bool*)a < *(const _Bool*)b ? -1 : 1; 
 }
 
@@ -44,47 +40,22 @@
 int main(int argc, char** argv) {
 	FILE* out = fopen("c-out.txt", "w");
-	srand(20171025);
-
-	struct stack s = new_stack();
-	REPEAT_TIMED( "push_int",
-		push_stack(&s, new_int( rand() ));
-	)
-
-	struct stack t;
-	TIMED( "copy_int",
-		copy_stack(&t, &s, copy_int); /***/
-	)
-
-	TIMED( "clear_int",
-		clear_stack(&s, free); /***/
-	)
-
 	int max = 0;
+	struct stack s = new_stack(), t;
+	REPEAT_TIMED( "push_int", push_stack(&s, new_int( _i )); )
+	TIMED( "copy_int", 	copy_stack(&t, &s, copy_int); /***/ )
+	TIMED( "clear_int", clear_stack(&s, free); /***/ )
 	REPEAT_TIMED( "pop_int", 
 		int* x = pop_stack(&t); /***/
 		if ( *x > max ) { max = *x; }
-		free(x);
-	)
-	print( out, "d", max, "\n" ); /***/
-
-	REPEAT_N_TIMED( "print_int", N/2, 
-		print( out, "dsds", rand(), ":", rand(), "\n" ); /***/
-	)
-
-	struct stack s2 = new_stack();
-	REPEAT_TIMED( "push_bool_char", 
-		push_stack(&s2, new_pair( new_bool( rand() & 0x1 ), new_char( rand() & 0x7F ) ));
-	)
-
-	struct stack t2;
-	TIMED( "copy_bool_char", 
-		copy_stack(&t2, &s2, copy_pair_bool_char); /***/
-	)
-
-	TIMED( "clear_bool_char", 
-		clear_stack(&s2, free_pair_bool_char); /***/
-	)
+		free(x); )
+	REPEAT_N_TIMED( "print_int", N/2, print( out, "dsds", _i, ":", _i, "\n" ); /***/ )
 
 	struct pair* max2 = new_pair( new_bool(0), new_char('\0') );
+	struct stack s2 = new_stack(), t2;
+
+	REPEAT_TIMED( "push_bool_char", 
+		push_stack(&s2, new_pair( new_bool( _i & 0x1 ), new_char( _i & 0x7F ) )); )
+	TIMED( "copy_bool_char", copy_stack(&t2, &s2, copy_pair_bool_char); /***/ )
+	TIMED( "clear_bool_char", clear_stack(&s2, free_pair_bool_char); /***/ )
 	REPEAT_TIMED( "pop_bool_char", 
 		struct pair* x = pop_stack(&t2); /***/
@@ -94,9 +65,5 @@
 		} else {
 			free_pair_bool_char( x ); /***/
-		}
-	)
-	print( out, "pbc", *max2, "\n" ); /***/
-	free_pair_bool_char( max2 ); /***/
-
+		} )
 	REPEAT_N_TIMED( "print_pair", N/2, 
 		struct pair p1 = ((struct pair){ new_bool(rand() & 0x1), new_char(rand() & 0x7F) }); /***/
@@ -104,7 +71,6 @@
 		print( out, "pbcspbcs", p1, ":", p2, "\n" ); /***/
 		free(p1.first); free(p1.second); /***/
-		free(p2.first); free(p2.second); /***/
-	)
-	
+		free(p2.first); free(p2.second); /***/ )
+	free_pair_bool_char( max2 ); /***/
 	fclose(out);
 }
Index: doc/generic_types/evaluation/c-print.h
===================================================================
--- doc/generic_types/evaluation/c-print.h	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/c-print.h	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,12 +1,8 @@
 #pragma once
-
 #include <stdio.h>
 
 void print_string(FILE* out, const char* x);
-
 void print_bool(FILE* out, _Bool x);
-
 void print_char(FILE* out, char x);
-
 void print_int(FILE* out, int x);
 
Index: doc/generic_types/evaluation/c-stack.c
===================================================================
--- doc/generic_types/evaluation/c-stack.c	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/c-stack.c	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -7,7 +7,5 @@
 };
 
-struct stack new_stack() {
-	return (struct stack){ NULL }; /***/
-}
+struct stack new_stack() { return (struct stack){ NULL }; /***/ }
 
 void copy_stack(struct stack* s, const struct stack* t, void* (*copy)(const void*)) {
@@ -34,7 +32,5 @@
 }
 
-_Bool stack_empty(const struct stack* s) {
-	return s->head == NULL;
-}
+_Bool stack_empty(const struct stack* s) { return s->head == NULL; }
 
 void push_stack(struct stack* s, void* value) {
Index: doc/generic_types/evaluation/c-stack.h
===================================================================
--- doc/generic_types/evaluation/c-stack.h	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/c-stack.h	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -2,5 +2,4 @@
 
 struct stack_node;
-
 struct stack {
 	struct stack_node* head;
@@ -8,12 +7,8 @@
 
 struct stack new_stack();
-
 void copy_stack(struct stack* dst, const struct stack* src, void* (*copy)(const void*));
-
 void clear_stack(struct stack* s, void (*free_el)(void*));
 
 _Bool stack_empty(const struct stack* s);
-
 void push_stack(struct stack* s, void* value);
-
 void* pop_stack(struct stack* s);
Index: doc/generic_types/evaluation/cfa-bench.c
===================================================================
--- doc/generic_types/evaluation/cfa-bench.c	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cfa-bench.c	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -10,18 +10,25 @@
 	int max = 0;
 	stack(int) s, t;
+
 	REPEAT_TIMED( "push_int", push( &s, _i ); )
 	TIMED( "copy_int", t = s; )
 	TIMED( "clear_int", clear( &s ); )
-	REPEAT_TIMED( "pop_int", max = max( max, pop( &t ) ); )
+	REPEAT_TIMED( "pop_int", 
+		int x = pop(&t); 
+		if ( x > max ) { max = x; } )
 	REPEAT_TIMED( "print_int", print( out, _i, ":", _i, "\n" ); )
 
 	stack(pair(_Bool, char)) s1, t1;
 	pair(_Bool, char) max = { (_Bool)0, '\0' };
+
 	REPEAT_TIMED( "push_pair", push( &s1, (pair(_Bool, char)){ _i & 1, _i &0x7F } ); )
 	TIMED( "copy_pair", t1 = s1; )
 	TIMED( "clear_pair", clear( &s1 ); )
-	REPEAT_TIMED( "pop_pair", max = max( max, pop( &t1 ) ); )
+	REPEAT_TIMED( "pop_pair",
+		pair(_Bool, char) x = pop(&t1); 
+		if ( x > max ) { max = x; } )
 	REPEAT_TIMED( "print_pair",
-		 print( out, (pair(_Bool, char)){  _i & 1, _i &0x7F }, ":", (pair(_Bool, char)){  _i & 1, _i &0x7F }, "\n" ); )
+		 print( out, (pair(_Bool, char)){  _i & 1, _i &0x7F }, ":", 
+		 	(pair(_Bool, char)){  _i & 1, _i &0x7F }, "\n" ); )
 	fclose(out);
 }
Index: doc/generic_types/evaluation/cfa-print.h
===================================================================
--- doc/generic_types/evaluation/cfa-print.h	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cfa-print.h	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,4 +1,3 @@
 #pragma once
-
 #include <stdio.h>
 #include "pair"
@@ -8,9 +7,6 @@
 
 void print(FILE* out, const char* x);
-
 void print(FILE* out, _Bool x);
-
 void print(FILE* out, char x);
-
 void print(FILE* out, int x);
 
Index: doc/generic_types/evaluation/cfa-stack.c
===================================================================
--- doc/generic_types/evaluation/cfa-stack.c	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cfa-stack.c	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -7,19 +7,5 @@
 };
 
-forall(otype T) void ?{}(stack(T)* s) {
-	(&s->head){ 0 };
-}
-
-forall(otype T) void copy(stack(T)* s, stack(T)* t) {
-	stack_node(T)** crnt = &s->head;
-	stack_node(T)* next = t->head;
-	while ( next ) {
-		*crnt = ((stack_node(T)*)malloc()){ next->value }; /***/
-		stack_node(T)* acrnt = *crnt;
-		crnt = &acrnt->next;
-		next = next->next;
-	}
-	*crnt = 0;
-}
+forall(otype T) void ?{}(stack(T)* s) { (&s->head){ 0 }; }
 
 forall(otype T) void ?{}(stack(T)* s, stack(T) t) {
@@ -42,11 +28,7 @@
 }
 
-forall(otype T) void ^?{}(stack(T)* s) {
-	clear(s);
-}
+forall(otype T) void ^?{}(stack(T)* s) { clear(s); }
 
-forall(otype T) _Bool empty(const stack(T)* s) {
-	return s->head == 0;
-}
+forall(otype T) _Bool empty(const stack(T)* s) { return s->head == 0; }
 
 forall(otype T) void push(stack(T)* s, T value) {
Index: doc/generic_types/evaluation/cfa-stack.h
===================================================================
--- doc/generic_types/evaluation/cfa-stack.h	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cfa-stack.h	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -2,5 +2,4 @@
 
 forall(otype T) struct stack_node;
-
 forall(otype T) struct stack {
 	stack_node(T)* head;
@@ -8,16 +7,10 @@
 
 forall(otype T) void ?{}(stack(T)* s);
-
 forall(otype T) void ?{}(stack(T)* s, stack(T) t);
-
 forall(otype T) stack(T) ?=?(stack(T)* s, stack(T) t);
-
 forall(otype T) void ^?{}(stack(T)* s);
 
 forall(otype T) _Bool empty(const stack(T)* s);
-
 forall(otype T) void push(stack(T)* s, T value);
-
 forall(otype T) T pop(stack(T)* s);
-
 forall(otype T) void clear(stack(T)* s);
Index: doc/generic_types/evaluation/cpp-bench.cpp
===================================================================
--- doc/generic_types/evaluation/cpp-bench.cpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-bench.cpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -8,7 +8,8 @@
 int main(int argc, char** argv) {
 	std::ofstream out{"cpp-out.txt"};
+	int max = 0;
 	stack<int> s, t;
-	int max = 0;
-	REPEAT_TIMED( "push_int", s.push( _i ); )
+	
+	REPEAT_TIMED( "push_int", s.push( int{_i} ); )
 	TIMED( "copy_int", t = s; )
 	TIMED( "clear_int", s.clear(); )
@@ -17,6 +18,7 @@
 	REPEAT_N_TIMED( "print_int", N/2, print( out, _i, ":", _i, "\n" ); )
 
+	std::pair<bool, char> max1 = { false, '\0' };
 	stack<std::pair<bool, char>> s1, t1;
-	std::pair<bool, char> max1 = { false, '\0' };
+	
 	REPEAT_TIMED( "push_bool_char", s1.push( std::pair<bool, char>{ _i & 0x1, _i & 0x7F } ); )
 	TIMED( "copy_bool_char", t1 = s1; )
Index: doc/generic_types/evaluation/cpp-print.hpp
===================================================================
--- doc/generic_types/evaluation/cpp-print.hpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-print.hpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,21 +1,17 @@
 #pragma once
-
 #include <iomanip>
 #include <iostream>
 #include <utility>
 
-template<typename T>
-void print(std::ostream& out, const T& x) { out << x; }
+template<typename T> void print(std::ostream& out, const T& x) { out << x; }
 
-template<>
-void print<bool>(std::ostream& out, const bool& x) { out << (x ? "true" : "false"); }
+template<> void print<bool>(std::ostream& out, const bool& x) { out << (x ? "true" : "false"); }
 
-template<>
-void print<char>(std::ostream& out, const char& x ) {
+template<> void print<char>(std::ostream& out, const char& x ) {
 	if ( 0x20 <= x && x <= 0x7E ) { out << "'" << x << "'"; }
 	else { out << "'\\" << std::hex << (unsigned int)x << std::setbase(0) << "'"; }
 }
 
-template<typename R, typename S>
+template<typename R, typename S> 
 std::ostream& operator<< (std::ostream& out, const std::pair<R, S>& x) {
 	out << "[";
@@ -26,5 +22,5 @@
 }
 
-template<typename T, typename... Args>
+template<typename T, typename... Args> 
 void print(std::ostream& out, const T& arg, const Args&... rest) {
 	out << arg;
Index: doc/generic_types/evaluation/cpp-stack.hpp
===================================================================
--- doc/generic_types/evaluation/cpp-stack.hpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-stack.hpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,4 +1,3 @@
 #pragma once
-
 #include <utility>
 
@@ -11,5 +10,4 @@
 		node( T&& v, node* n ) : value(std::move(v)), next(n) {}
 	};
-	
 	node* head;
 
@@ -24,5 +22,4 @@
 		*crnt = nullptr;
 	}
-
 public:
 	void clear() {
@@ -37,9 +34,6 @@
 
 	stack() : head(nullptr) {}
-
 	stack(const stack<T>& o) { copy(o); }
-
 	stack(stack<T>&& o) : head(o.head) { o.head = nullptr; }
-
 	~stack() { clear(); }
 
@@ -58,11 +52,7 @@
 	}
 
-	bool empty() const {
-		return head == nullptr;
-	}
+	bool empty() const { return head == nullptr; }
 
-	void push(T&& value) {
-		head = new node{ std::move(value), head };  /***/
-	}
+	void push(T&& value) { head = new node{ std::move(value), head };  /***/ }
 
 	T pop() {
Index: doc/generic_types/evaluation/cpp-vbench.cpp
===================================================================
--- doc/generic_types/evaluation/cpp-vbench.cpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-vbench.cpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -8,6 +8,7 @@
 int main(int argc, char** argv) {
 	std::ofstream out{"cpp-vout.txt"};
+	integer max{ 0 };
 	stack s, t;
-	integer max{ 0 };
+	
 	REPEAT_TIMED( "push_int", s.push( make<integer>( _i ) ); )
 	TIMED( "copy_int", t = s; )
@@ -18,6 +19,7 @@
 		print( out, integer{_i}, c_string{":"}, integer{_i}, c_string{"\n"} ); )
 
+	ptr<pair> max1 = make<pair>( make<boolean>(false), make<character>('\0') );
 	stack s1, t1;
-	ptr<pair> max1 = make<pair>( make<boolean>(false), make<character>('\0') );
+	
 	REPEAT_TIMED( "push_bool_char", 
 		s1.push( make<pair>( make<boolean>(_i & 1), make<character>(_i & 0x7F) ) ); )
Index: doc/generic_types/evaluation/cpp-vprint.hpp
===================================================================
--- doc/generic_types/evaluation/cpp-vprint.hpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-vprint.hpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,4 +1,3 @@
 #pragma once
-
 #include <ostream>
 #include "object.hpp"
@@ -6,6 +5,5 @@
 void print(std::ostream& out, const printable& x) { x.print(out); }
 
-template<typename... Args>
-void print(std::ostream& out, const printable& x, const Args&... rest) {
+template<typename... Args> void print(std::ostream& out, const printable& x, const Args&... rest) {
 	x.print(out);
 	print(out, rest...);
Index: doc/generic_types/evaluation/cpp-vstack.cpp
===================================================================
--- doc/generic_types/evaluation/cpp-vstack.cpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-vstack.cpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,8 +1,6 @@
 #include "cpp-vstack.hpp"
-
 #include <utility>
 
 stack::node::node( const object& v ) : value( v.new_copy() ), next( nullptr ) {}
-
 stack::node::node( ptr<object>&& v, node* n ) : value( std::move(v) ), next( n ) {}
 
@@ -18,20 +16,7 @@
 }
 
-void stack::clear() {
-	node* next = head;
-	while ( next ) {
-		node* crnt = next;
-		next = crnt->next;
-		delete crnt;
-	}
-	head = nullptr;
-}
-
 stack::stack() : head(nullptr) {}
-
 stack::stack(const stack& o) { copy(o); }
-
 stack::stack(stack&& o) : head(o.head) { o.head = nullptr; }
-
 stack::~stack() { clear(); }
 
@@ -50,4 +35,15 @@
 }
 
+void stack::clear() {
+	node* next = head;
+	while ( next ) {
+		node* crnt = next;
+		next = crnt->next;
+		delete crnt;
+	}
+	head = nullptr;
+}
+
+
 bool stack::empty() const { return head == nullptr; }
 
Index: doc/generic_types/evaluation/cpp-vstack.hpp
===================================================================
--- doc/generic_types/evaluation/cpp-vstack.hpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/cpp-vstack.hpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,4 +1,3 @@
 #pragma once
-
 #include "object.hpp"
 
@@ -9,31 +8,20 @@
 
 		node( const object& v );
-
 		node( ptr<object>&& v, node* n );
 	};
-
 	node* head;
 
 	void copy(const stack& o);
-
 public:
-	void clear();
-
 	stack();
-
 	stack(const stack& o);
-
 	stack(stack&& o);
-
 	~stack();
-
 	stack& operator= (const stack& o);
-	
 	stack& operator= (stack&& o);
 
+	void clear();
 	bool empty() const;
-
 	void push(ptr<object>&& value);
-
 	ptr<object> pop();
 };
Index: doc/generic_types/evaluation/object.hpp
===================================================================
--- doc/generic_types/evaluation/object.hpp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/object.hpp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,4 +1,3 @@
 #pragma once
-
 #include <cstddef>
 #include <exception>
@@ -16,5 +15,4 @@
 		why = std::string{"bad cast of "} + f.name() + " to " + t.name();
 	}
-
 	~bad_cast() override = default;
 	
@@ -22,15 +20,12 @@
 };
 
-template<typename T>
-std::type_index class_of() { return { typeid(T) }; }
+template<typename T> std::type_index class_of() { return { typeid(T) }; }
 
 template<typename T> using ptr = std::unique_ptr<T>;
 
-class object {
-public:
+struct object {
 	std::type_index get_class() const { return { this ? typeid(*this) : typeid(std::nullptr_t) }; }
 
-	template<typename T>
-	T& as() {
+	template<typename T> T& as() {
 		T* p = dynamic_cast<T*>(this);
 		if ( !p ) throw bad_cast{ get_class(), class_of<T>() };
@@ -38,6 +33,5 @@
 	}
 
-	template<typename T>
-	const T& as() const {
+	template<typename T> const T& as() const {
 		const T* p = dynamic_cast<const T*>(this);
 		if ( !p ) throw bad_cast{ get_class(), class_of<T>() };
@@ -46,37 +40,28 @@
 
 	virtual ptr<object> new_inst() const = 0;
-	
 	virtual ptr<object> new_copy() const = 0;
-	
 	virtual object& operator= (const object&) = 0;
-	
 	virtual ~object() = default;
 };
 
-template<typename T, typename... Args>
-static inline ptr<T> make(Args&&... args) { return std::make_unique<T>(std::forward<Args>(args)...); }
+template<typename T, typename... Args> static inline ptr<T> make(Args&&... args) {
+	return std::make_unique<T>(std::forward<Args>(args)...);
+}
 
-template<typename To, typename From>
+template<typename To, typename From> 
 ptr<To> as_ptr( ptr<From>&& p ) { return ptr<To>{ &p.release()->template as<To>() }; }
 
-class ordered : public virtual object {
-public:
+struct ordered : public virtual object {
 	virtual int cmp(const ordered&) const = 0;
 
 	bool operator< (const ordered& that) const { return cmp(that) < 0; }
-
 	bool operator<= ( const ordered& that ) const { return cmp(that) <= 0; }
-
 	bool operator== ( const ordered& that ) const { return cmp(that) == 0; }
-
 	bool operator!= ( const ordered& that ) const { return cmp(that) != 0; }
-
 	bool operator> ( const ordered& that ) const { return cmp(that) > 0; }
-
 	bool operator>= ( const ordered& that ) const { return cmp(that) >= 0; }
 };
 
-class printable : public virtual object {
-public:
+struct printable : public virtual object {
 	virtual void print(std::ostream&) const = 0;
 };
@@ -84,25 +69,17 @@
 class boolean : public ordered, public printable {
 	bool x;
-
 public:
 	boolean() = default;
-
 	boolean(bool x) : x(x) {}
-
 	ptr<object> new_inst() const override { return make<boolean>(); }
-	
 	ptr<object> new_copy() const override { return make<boolean>(*this); }
-
 	boolean& operator= (const boolean& that) {
 		x = that.x;
 		return *this;	
 	}
-
 	object& operator= (const object& that) override { return *this = that.as<boolean>(); } /***/
-
 	~boolean() override = default;
 
 	int cmp(const boolean& that) const { return x == that.x ? 0 : x == false ? -1 : 1; }
-
 	int cmp(const ordered& that) const override { return cmp( that.as<boolean>() ); } /***/
 
@@ -112,25 +89,17 @@
 class character : public ordered, public printable {
 	char x;
-
 public:
 	character() = default;
-
 	character(char x) : x(x) {}
-
 	ptr<object> new_inst() const override { return make<character>(); }
-	
 	ptr<object> new_copy() const override { return make<character>(*this); }
-
 	character& operator= (const character& that) {
 		x = that.x;
 		return *this;	
 	}
-
 	object& operator= (const object& that) override { return *this = that.as<character>(); } /***/
-
 	~character() override = default;
 
 	int cmp(const character& that) const { return x == that.x ? 0 : x < that.x ? -1 : 1; }
-
 	int cmp(const ordered& that) const override { return cmp( that.as<character>() ); } /***/
 
@@ -143,25 +112,17 @@
 class integer : public ordered, public printable {
 	int x;
-
 public:
 	integer() = default;
-
 	integer(int x) : x(x) {}
-
 	ptr<object> new_inst() const override { return make<integer>(); }
-	
 	ptr<object> new_copy() const override { return make<integer>(*this); }
-
 	integer& operator= (const integer& that) {
 		x = that.x;
 		return *this;	
 	}
-
 	object& operator= (const object& that) override { return *this = that.as<integer>(); } /***/
-
 	~integer() override = default;
 
 	int cmp(const integer& that) const { return x == that.x ? 0 : x < that.x ? -1 : 1; }
-
 	int cmp(const ordered& that) const override { return cmp( that.as<integer>() ); } /***/
 
@@ -174,18 +135,12 @@
 public:
 	c_string() : s(empty) {}
-
 	c_string(const char* s) : s(s) {}
-
 	ptr<object> new_inst() const override { return make<c_string>(); }
-
 	ptr<object> new_copy() const override { return make<c_string>(s); }
-
 	c_string& operator= (const c_string& that) {
 		s = that.s;
 		return *this;
 	}
-
 	object& operator= (const object& that) override { return *this = that.as<c_string>(); } /***/
-
 	~c_string() override = default;
 
@@ -196,16 +151,9 @@
 	ptr<object> x;
 	ptr<object> y;
-
 public:
 	pair() = default;
-
 	pair(ptr<object>&& x, ptr<object>&& y) : x(std::move(x)), y(std::move(y)) {}
-	
 	ptr<object> new_inst() const override { return make<pair>(); }
-
-	ptr<object> new_copy() const override {
-		return make<pair>(x->new_copy(), y->new_copy());
-	}
-
+	ptr<object> new_copy() const override { return make<pair>(x->new_copy(), y->new_copy()); }
 	pair& operator= (const pair& that) {
 		x = that.x->new_copy();
@@ -213,7 +161,5 @@
 		return *this;
 	}
-
 	object& operator= (const object& that) override { return *this = that.as<pair>(); } /***/
-
 	~pair() override = default;
 
@@ -223,5 +169,4 @@
 		return y->as<ordered>().cmp( that.y->as<ordered>() ); /***/
 	}
-
 	int cmp(const ordered& that) const override { return cmp( that.as<pair>() ); }
 
Index: doc/generic_types/evaluation/timing.csv
===================================================================
--- doc/generic_types/evaluation/timing.csv	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ 	(revision )
@@ -1,12 +1,0 @@
-"400 million repetitions","C","\\CFA{}","\\CC{}","\\CC{obj}"
-"push\nint",3358,2616,1929,3559
-"copy\nint",2966,2268,1534,3097
-"clear\nint",1343,834,708,1487
-"pop\nint",1385,2728,711,5122
-"print\nint",6609,17157,5006,5023
-"push\npair",4930,3708,1795,7136
-"copy\npair",6203,1920,996,7043
-"clear\npair",2811,875,712,3393
-"pop\npair",3054,8283,883,21262
-"print\npair",12364,27693,10448,21468
-
Index: doc/generic_types/evaluation/timing.dat
===================================================================
--- doc/generic_types/evaluation/timing.dat	(revision a381b46f28e115a62848831837d838570a0da573)
+++ doc/generic_types/evaluation/timing.dat	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -0,0 +1,12 @@
+"400 million repetitions"	"C"	"\\CFA{}"	"\\CC{}"	"\\CC{obj}"
+"push\nint"	3324	2263	1583	3141
+"copy\nint"	2999	2055	1560	3136
+"clear\nint"	1384	816	754	1498
+"pop\nint"	1413	1172	751	5344
+"print\nint"	7106	12458	3976	4044
+"push\npair"	4916	3139	1014	6407
+"copy\npair"	6218	2077	1002	7067
+"clear\npair"	2777	886	722	3519
+"pop\npair"	2857	4200	784	21145
+"print\npair"	13536	21726	9009	20516
+
Index: doc/generic_types/evaluation/timing.gp
===================================================================
--- doc/generic_types/evaluation/timing.gp	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/evaluation/timing.gp	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1,4 +1,4 @@
 # set terminal pdfcairo linewidth 3 size 6,3
-#set terminal postscript eps linewidth 3 size 6,3
+# set output "timing.pdf"
 set terminal pslatex size 6.25,2.25 color solid
 set output "timing.tex"
@@ -20,7 +20,7 @@
 set linetype 4 lc rgb 'green'
 
-set ylabel "milli-seconds"
+set ylabel "milliseconds"
 set yrange [0:*] ;
 
-set datafile separator ","
-plot for [COL=2:5] 'evaluation/timing.csv' using COL:xticlabels(1) title columnheader
+# set datafile separator ","
+plot for [COL=2:5] 'evaluation/timing.dat' using COL:xticlabels(1) title columnheader
Index: doc/generic_types/generic_types.tex
===================================================================
--- doc/generic_types/generic_types.tex	(revision 308880c62efc9d218aa37bd1cccefca934608e56)
+++ doc/generic_types/generic_types.tex	(revision a381b46f28e115a62848831837d838570a0da573)
@@ -1016,5 +1016,6 @@
 The benchmarks were run on an Ubuntu 16.04 workstation with 16 GB of RAM and a 6-core AMD FX-6300 CPU with 3.5 GHz maximum clock frequency.
 The C and \CCV variants are generally the slowest and most memory-hungry, due to their less-efficient memory layout and the pointer-indirection necessary to implement generic types in these languages; this problem is exacerbated by the second level of generic types in the pair-based benchmarks.
-By contrast, the \CFA and \CC variants run in roughly equivalent time for both the integer and pair of boolean and char tests, which makes sense given that an integer is actually larger than the pair in both languages.
+By contrast, the \CFA and \CC variants run in roughly equivalent time for both the integer and pair of boolean and char tests, which makes sense given that an integer is actually larger than the pair in both languages. 
+\CCV is slower than C largely due to the cost of runtime type-checking of down-casts (implemented here using the \CC @dynamic_cast@ mechanism); our C benchmark uses unchecked casts due to the lack of a language mechanism to perform such checks, while \CFA and \CC can enforce type-safety statically at compilation.
 
 \CC performs best because it uses header-only inlined libraries (\ie no separate compilation).
@@ -1123,12 +1124,103 @@
 \bibliography{cfa}
 
-
 \appendix
 
-
-\section{BenchMarks}
+\section{Benchmark Source Code}
 \label{sec:BenchMarks}
 
-TODO
+Throughout, @/***/@ designates a counted redundant type annotation.
+
+\subsubsection{bench.h}
+(\texttt{bench.hpp} is similar.)
+
+\lstinputlisting{evaluation/bench.h}
+
+\subsection{C}
+
+\subsubsection{c-stack.h} ~
+
+\lstinputlisting{evaluation/c-stack.h}
+
+\subsubsection{c-stack.c} ~
+
+\lstinputlisting{evaluation/c-stack.c}
+
+\subsubsection{c-pair.h} ~
+
+\lstinputlisting{evaluation/c-pair.h}
+
+\subsubsection{c-pair.c} ~
+
+\lstinputlisting{evaluation/c-pair.c}
+
+\subsubsection{c-print.h} ~
+
+\lstinputlisting{evaluation/c-print.h}
+
+\subsubsection{c-print.c} ~
+
+\lstinputlisting{evaluation/c-print.c}
+
+\subsubsection{c-bench.c} ~
+
+\lstinputlisting{evaluation/c-bench.c}
+
+\subsection{\CFA}
+
+\subsubsection{cfa-stack.h} ~
+
+\lstinputlisting{evaluation/cfa-stack.h}
+
+\subsubsection{cfa-stack.c} ~
+
+\lstinputlisting{evaluation/cfa-stack.c}
+
+\subsubsection{cfa-print.h} ~
+
+\lstinputlisting{evaluation/cfa-print.h}
+
+\subsubsection{cfa-print.c} ~
+
+\lstinputlisting{evaluation/cfa-print.c}
+
+\subsubsection{cfa-bench.c} ~
+
+\lstinputlisting{evaluation/cfa-bench.c}
+
+\subsection{\CC}
+
+\subsubsection{cpp-stack.hpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-stack.hpp}
+
+\subsubsection{cpp-print.hpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-print.hpp}
+
+\subsubsection{cpp-bench.cpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-bench.cpp}
+
+\subsection{\CCV}
+
+\subsubsection{object.hpp} ~
+
+\lstinputlisting[language=c++]{evaluation/object.hpp}
+
+\subsubsection{cpp-vstack.hpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-vstack.hpp}
+
+\subsubsection{cpp-vstack.cpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-vstack.cpp}
+
+\subsubsection{cpp-vprint.hpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-vprint.hpp}
+
+\subsubsection{cpp-vbench.cpp} ~
+
+\lstinputlisting[language=c++]{evaluation/cpp-vbench.cpp}
 
 \end{document}