Index: doc/theses/andrew_beach_MMath/code/CondCatch.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/CondCatch.java	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/CondCatch.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -6,23 +6,15 @@
 	static boolean should_catch = false;
 
-	static void throw_exception() throws EmptyException {
-		throw new EmptyException();
-	}
-
-	static void cond_catch() throws EmptyException {
-		try {
-			throw_exception();
-		} catch (EmptyException exc) {
-			if (!should_catch) {
-				throw exc;
-			}
-		}
-	}
-
 	private static long loop(int times) {
 		long startTime = System.nanoTime();
 		for (int count = 0 ; count < times ; ++count) {
 			try {
-				cond_catch();
+				try {
+					throw new EmptyException();
+				} catch (EmptyException exc) {
+					if (!should_catch) {
+						throw exc;
+					}
+				}
 			} catch (EmptyException exc) {
 				// ...
@@ -46,5 +38,5 @@
 
 		long time = loop(times);
-		System.out.println("Run-Time (ns): " + time);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
 	}
 }
Index: doc/theses/andrew_beach_MMath/code/CrossCatch.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/CrossCatch.java	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,35 +1,0 @@
-// Enter and Leave a Try Statement with a Termination Handler
-
-class NotRaisedException extends Exception {}
-
-public class CrossCatch {
-	private static boolean shouldThrow = false;
-
-	private static long loop(int times) {
-		long startTime = System.nanoTime();
-		for (int count = 0 ; count < times ; ++count) {
-			try {
-				if (shouldThrow) {
-					throw new NotRaisedException();
-				}
-			} catch (NotRaisedException e) {
-				// ...
-			}
-		}
-		long endTime = System.nanoTime();
-		return endTime - startTime;
-	}
-
-	public static void main(String[] args) {
-		int times = 1;
-		if (0 < args.length) {
-			times = Integer.parseInt(args[0]);
-		}
-
-		// Warm-Up:
-		loop(1000);
-
-		long time = loop(times);
-		System.out.println("Run-Time (ns): " + time);
-	}
-}
Index: doc/theses/andrew_beach_MMath/code/CrossFinally.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/CrossFinally.java	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,31 +1,0 @@
-// Cross a Try Statement with a Finally Clause
-
-public class CrossFinally {
-	private static boolean shouldThrow = false;
-
-	private static long loop(int times) {
-		long startTime = System.nanoTime();
-		for (int count = 0 ; count < times ; ++count) {
-			try {
-				// ...
-			} finally {
-				// ...
-			}
-		}
-		long endTime = System.nanoTime();
-		return endTime - startTime;
-	}
-
-	public static void main(String[] args) {
-		int times = 1;
-		if (0 < args.length) {
-			times = Integer.parseInt(args[0]);
-		}
-
-		// Warm-Up:
-		loop(1000);
-
-		long time = loop(times);
-		System.out.println("Run-Time (ns): " + time);
-	}
-}
Index: doc/theses/andrew_beach_MMath/code/ResumeFixupEmpty.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/ResumeFixupEmpty.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/ResumeFixupEmpty.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,42 @@
+public class ResumeFixupEmpty {
+	public interface Fixup {
+		public int op(int fixup);
+	}
+
+	static void nounwind_fixup(int frames, Fixup raised_rtn) {
+		if (0 < frames) {
+			nounwind_fixup(frames - 1, raised_rtn);
+		} else {
+			int fixup = frames;
+			fixup = raised_rtn.op(fixup);
+		}
+	}
+
+	private static long loop(int times, int total_frames) {
+		Fixup raised = (int fixup) -> total_frames + 42; // use local scope => lexical link
+
+		long startTime = System.nanoTime();
+		for (int count = 0 ; count < times ; ++count) {
+			nounwind_fixup(total_frames, raised);
+		}
+		long endTime = System.nanoTime();
+		return endTime - startTime;
+	}
+
+	public static void main(String[] args) {
+		int times = 1;
+		int total_frames = 1;
+		if (0 < args.length) {
+			times = Integer.parseInt(args[0]);
+		}
+		if (1 < args.length) {
+			total_frames = Integer.parseInt(args[1]);
+		}
+
+		// Warm-Up:
+		loop(1000, total_frames);
+
+		long time = loop(times, total_frames);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
+	}
+}
Index: doc/theses/andrew_beach_MMath/code/ResumeFixupOther.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/ResumeFixupOther.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/ResumeFixupOther.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,44 @@
+public class ResumeFixupOther {
+	public interface Fixup {
+		public int op(int fixup);
+	}
+
+	static void nounwind_fixup(int frames, Fixup raised_rtn, Fixup not_raised_rtn) {
+	 	Fixup not_raised = (int fixup) -> frames + 42; // use local scope => lexical link
+		if (0 < frames) {
+			nounwind_fixup(frames - 1, raised_rtn, not_raised);
+		} else {
+			int fixup = 17;
+			fixup = raised_rtn.op(fixup);
+		}
+	}
+
+	private static long loop(int times, int total_frames) {
+		Fixup raised = (int fixup) -> total_frames + 42; // use local scope => lexical link
+		Fixup not_raised = (int fixup) -> total_frames + 42; // use local scope => lexical link
+
+		long startTime = System.nanoTime();
+		for (int count = 0 ; count < times ; ++count) {
+		    nounwind_fixup(total_frames, raised, not_raised);
+		}
+		long endTime = System.nanoTime();
+		return endTime - startTime;
+	}
+
+	public static void main(String[] args) {
+		int times = 1;
+		int total_frames = 1;
+		if (0 < args.length) {
+			times = Integer.parseInt(args[0]);
+		}
+		if (1 < args.length) {
+			total_frames = Integer.parseInt(args[1]);
+		}
+
+		// Warm-Up:
+		loop(1000, total_frames);
+
+		long time = loop(times, total_frames);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
+	}
+}
Index: doc/theses/andrew_beach_MMath/code/ThrowEmpty.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/ThrowEmpty.java	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/ThrowEmpty.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -39,5 +39,5 @@
 
 		long time = loop(times, total_frames);
-		System.out.println("Run-Time (ns): " + time);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
 	}
 }
Index: doc/theses/andrew_beach_MMath/code/ThrowFinally.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/ThrowFinally.java	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/ThrowFinally.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -44,5 +44,5 @@
 
 		long time = loop(times, total_frames);
-		System.out.println("Run-Time (ns): " + time);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
 	}
 }
Index: doc/theses/andrew_beach_MMath/code/ThrowOther.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/ThrowOther.java	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/ThrowOther.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -52,5 +52,5 @@
 
 		long time = loop(times, total_frames);
-		System.out.println("Run-Time (ns): " + time);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
 	}
 }
Index: doc/theses/andrew_beach_MMath/code/TryCatch.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/TryCatch.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/TryCatch.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,35 @@
+// Enter and Leave a Try Statement with a Termination Handler
+
+class NotRaisedException extends Exception {}
+
+public class TryCatch {
+	private static boolean shouldThrow = false;
+
+	private static long loop(int times) {
+		long startTime = System.nanoTime();
+		for (int count = 0 ; count < times ; ++count) {
+			try {
+				if (shouldThrow) {
+					throw new NotRaisedException();
+				}
+			} catch (NotRaisedException e) {
+				// ...
+			}
+		}
+		long endTime = System.nanoTime();
+		return endTime - startTime;
+	}
+
+	public static void main(String[] args) {
+		int times = 1;
+		if (0 < args.length) {
+			times = Integer.parseInt(args[0]);
+		}
+
+		// Warm-Up:
+		loop(1000);
+
+		long time = loop(times);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
+	}
+}
Index: doc/theses/andrew_beach_MMath/code/TryFinally.java
===================================================================
--- doc/theses/andrew_beach_MMath/code/TryFinally.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/TryFinally.java	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,31 @@
+// Enter and Leave a Try Statement with a Finally Handler
+
+public class TryFinally {
+	private static boolean shouldThrow = false;
+
+	private static long loop(int times) {
+		long startTime = System.nanoTime();
+		for (int count = 0 ; count < times ; ++count) {
+			try {
+				// ...
+			} finally {
+				// ...
+			}
+		}
+		long endTime = System.nanoTime();
+		return endTime - startTime;
+	}
+
+	public static void main(String[] args) {
+		int times = 1;
+		if (0 < args.length) {
+			times = Integer.parseInt(args[0]);
+		}
+
+		// Warm-Up:
+		loop(1000);
+
+		long time = loop(times);
+		System.out.format("Run-Time (s): %.1f%n", time / 1_000_000_000.);
+	}
+}
Index: doc/theses/andrew_beach_MMath/code/cond-catch.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/cond-catch.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/cond-catch.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,31 +3,18 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.h>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
-
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
 bool should_catch = false;
-
-void throw_exception() {
-	throw (empty_exception){&empty_vt};
-}
-
-void cond_catch() {
-	try {
-		throw_exception();
-	} catch (empty_exception * exc ; should_catch) {
-		asm volatile ("# catch block (conditional)");
-	}
-}
 
 int main(int argc, char * argv[]) {
 	unsigned int times = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		should_catch = strtol(argv[2], 0p, 10);
+		should_catch = (unsigned int)strto(argv[2], 0p, 2);
 	}
 
@@ -35,5 +22,7 @@
 	for (unsigned int count = 0 ; count < times ; ++count) {
 		try {
-			cond_catch();
+			throw (empty_exception){&empty_vt};
+		} catch (empty_exception * exc ; should_catch) {
+			asm volatile ("# catch block (conditional)");
 		} catch (empty_exception * exc) {
 			asm volatile ("# catch block (unconditional)");
@@ -41,4 +30,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/cond-catch.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/cond-catch.cpp	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/cond-catch.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -4,5 +4,7 @@
 #include <exception>
 #include <iostream>
+#include <iomanip>
 
+using namespace std;
 using namespace std::chrono;
 
@@ -10,19 +12,4 @@
 
 bool should_catch = false;
-
-void throw_exception() {
-	throw EmptyException();
-}
-
-void cond_catch() {
-	try {
-		throw_exception();
-	} catch (EmptyException & exc) {
-		if (!should_catch) {
-			throw;
-		}
-		asm volatile ("# catch block (conditional)");
-	}
-}
 
 int main(int argc, char * argv[]) {
@@ -38,5 +25,12 @@
     for (unsigned int count = 0 ; count < times ; ++count) {
         try {
-			cond_catch();
+			try {
+				throw EmptyException();
+			} catch (EmptyException & exc) {
+				if (!should_catch) {
+					throw;
+				}
+				asm volatile ("# catch block (conditional)");
+			}
 		} catch (EmptyException &) {
 			asm volatile ("# catch block (unconditional)");
@@ -45,4 +39,4 @@
 	time_point<steady_clock> end_time = steady_clock::now();
 	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
-	std::cout << "Run-Time (ns): " << duration.count() << std::endl;
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
 }
Index: doc/theses/andrew_beach_MMath/code/cond-catch.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/cond-catch.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/cond-catch.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+
+# Conditional Match (or Re-Raise)
+
+from time import thread_time_ns
+
+
+class EmptyException(Exception):
+    pass
+
+
+should_catch = False
+
+
+def main(argv):
+    times = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        should_catch = 0 < int(argv[2])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            try:
+                raise EmptyException()
+            except EmptyException as exc:
+                if not should_catch:
+                    raise
+        except EmptyException:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/cond-fixup.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/cond-fixup.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/cond-fixup.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,31 +3,18 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
-
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
 bool should_catch = false;
-
-void throw_exception() {
-	throwResume (empty_exception){&empty_vt};
-}
-
-void cond_catch() {
-	try {
-		throw_exception();
-	} catchResume (empty_exception * exc ; should_catch) {
-		asm volatile ("# fixup block (conditional)");
-	}
-}
 
 int main(int argc, char * argv[]) {
 	unsigned int times = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		should_catch = strtol(argv[2], 0p, 10);
+		should_catch = (unsigned int)strto(argv[2], 0p, 2);
 	}
 
@@ -35,5 +22,7 @@
 	for (unsigned int count = 0 ; count < times ; ++count) {
 		try {
-			cond_catch();
+			throwResume (empty_exception){&empty_vt};
+		} catchResume (empty_exception * exc ; should_catch) {
+			asm volatile ("# fixup block (conditional)");
 		} catchResume (empty_exception * exc) {
 			asm volatile ("# fixup block (unconditional)");
@@ -41,4 +30,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/cond_catch.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/cond_catch.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,47 +1,0 @@
-#!/usr/bin/env python3
-
-# Conditional Match (or Re-Raise)
-
-from time import thread_time_ns
-
-
-class EmptyException(Exception):
-    pass
-
-
-should_catch = False
-
-
-def throw_exception():
-    raise EmptyException()
-
-
-def cond_catch():
-    try:
-        throw_exception()
-    except EmptyException as exc:
-        if not should_catch:
-            raise
-
-
-def main(argv):
-    times = 1
-    if 1 < len(argv):
-        times = int(argv[1])
-    if 2 < len(argv):
-        should_catch = 0 < int(argv[2])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            cond_catch();
-        except EmptyException:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/cross-catch.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/cross-catch.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,31 +1,0 @@
-// Cross a Try Statement with a Termination Handler
-#include <clock.hfa>
-#include <exception.hfa>
-#include <fstream.hfa>
-#include <stdlib.hfa>
-
-EHM_EXCEPTION(not_raised_exception)();
-
-EHM_VIRTUAL_TABLE(not_raised_exception, not_vt);
-
-int main(int argc, char * argv[]) {
-	unsigned int times = 1;
-	volatile bool should_throw = false;
-	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
-	}
-
-	Time start_time = timeHiRes();
-	for (unsigned int count = 0 ; count < times ; ++count) {
-		try {
-			asm volatile ("# try block");
-			if (should_throw) {
-				throw (not_raised_exception){&not_vt};
-			}
-		} catch (not_raised_exception *) {
-			asm volatile ("# catch block");
-		}
-	}
-	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
-}
Index: doc/theses/andrew_beach_MMath/code/cross-catch.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/cross-catch.cpp	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,32 +1,0 @@
-// Cross a Try Statement with a Termination Handler
-#include <chrono>
-#include <cstdlib>
-#include <exception>
-#include <iostream>
-
-using namespace std::chrono;
-
-struct NotRaisedException : public std::exception {};
-
-int main(int argc, char * argv[]) {
-	unsigned int times = 1;
-	volatile bool should_throw = false;
-	if (1 < argc) {
-		times = strtol(argv[1], nullptr, 10);
-	}
-
-	time_point<steady_clock> start_time = steady_clock::now();
-	for (unsigned int count = 0 ; count < times ; ++count) {
-		try {
-			asm volatile ("# try block");
-			if (should_throw) {
-				throw NotRaisedException();
-			}
-		} catch (NotRaisedException &) {
-			asm volatile ("# catch block");
-		}
-	}
-	time_point<steady_clock> end_time = steady_clock::now();
-	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
-	std::cout << "Run-Time (ns): " << duration.count() << std::endl;
-}
Index: doc/theses/andrew_beach_MMath/code/cross-finally.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/cross-finally.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,31 +1,0 @@
-// Cross a Try Statement With Finally Clause
-#include <clock.hfa>
-#include <exception.hfa>
-#include <fstream.hfa>
-#include <stdlib.hfa>
-
-EHM_EXCEPTION(not_raised_exception)();
-
-EHM_VIRTUAL_TABLE(not_raised_exception, not_vt);
-
-int main(int argc, char * argv[]) {
-	unsigned int times = 1;
-	volatile bool should_throw = false;
-	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
-	}
-
-	Time start_time = timeHiRes();
-	for (unsigned int count = 0 ; count < times ; ++count) {
-		try {
-			asm volatile ("# try block");
-			if (should_throw) {
-				throw (not_raised_exception){&not_vt};
-			}
-		} finally {
-			asm volatile ("# finally block");
-		}
-	}
-	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
-}
Index: doc/theses/andrew_beach_MMath/code/cross-resume.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/cross-resume.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,29 +1,0 @@
-// Cross a Try Statement With Finally Clause
-#include <clock.hfa>
-#include <exception.hfa>
-#include <fstream.hfa>
-#include <stdlib.hfa>
-
-EHM_EXCEPTION(not_raised_exception)();
-
-int main(int argc, char * argv[]) {
-	unsigned int times = 1;
-	unsigned int total_frames = 1;
-	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
-	}
-	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
-	}
-
-	Time start_time = timeHiRes();
-	for (unsigned int count = 0 ; count < times ; ++count) {
-		try {
-			asm volatile ("");
-		} catchResume (not_raised_exception *) {
-			asm volatile ("");
-		}
-	}
-	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
-}
Index: doc/theses/andrew_beach_MMath/code/cross_catch.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/cross_catch.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,30 +1,0 @@
-#!/usr/bin/env python3
-
-# Cross a Try Statement with a Termination Handler
-
-from time import thread_time_ns
-
-
-class NotRaisedException(Exception):
-    pass
-
-
-def main(argv):
-    times = 1;
-    if 1 < len(argv):
-        times = int(argv[1])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            pass
-        except NotRaisedException:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/cross_finally.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/cross_finally.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,29 +1,0 @@
-#!/usr/bin/env python3
-
-# Cross a Try Statement With Finally Clause
-
-from time import thread_time_ns
-
-
-def main(argv):
-    times = 1;
-    total_frames = 1;
-    if 1 < len(argv):
-        times = int(argv[1])
-    if 2 < len(argv):
-        total_frames = int(argv[2])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            pass
-        finally:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/resume-detor.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-detor.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/resume-detor.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,9 +3,8 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
-
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
 struct WithDestructor {};
@@ -17,5 +16,4 @@
 void unwind_destructor(unsigned int frames) {
 	if (frames) {
-
 		WithDestructor object;
 		unwind_destructor(frames - 1);
@@ -29,8 +27,8 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
 
@@ -44,4 +42,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/resume-empty.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-empty.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/resume-empty.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,13 +3,12 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
-
-void unwind_empty(unsigned int frames) {
+void nounwind_empty(unsigned int frames) {
 	if (frames) {
-		unwind_empty(frames - 1);
+		nounwind_empty(frames - 1);
 	} else {
 		throwResume (empty_exception){&empty_vt};
@@ -21,14 +20,14 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
 
 	Time start_time = timeHiRes();
-	for (int count = 0 ; count < times ; ++count) {
+	for (unsigned int count = 0 ; count < times ; ++count) {
 		try {
-			unwind_empty(total_frames);
+			nounwind_empty(total_frames);
 		} catchResume (empty_exception *) {
 			asm volatile ("# fixup block");
@@ -36,4 +35,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/resume-finally.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-finally.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/resume-finally.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,9 +3,8 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
-
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
 void unwind_finally(unsigned int frames) {
@@ -25,8 +24,8 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
 
@@ -40,4 +39,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-empty-f.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-empty-f.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-empty-f.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,35 @@
+// Resume Across Fixup
+#include <clock.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+void nounwind_fixup(unsigned int frames, void (*raised_rtn)(int &)) {
+	if (frames) {
+		nounwind_fixup(frames - 1, raised_rtn);
+	} else {
+		int fixup = 17;
+		raised_rtn(fixup);
+	}
+}
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+	if (2 < argc) {
+		total_frames = strto(argv[2], 0p, 10);
+	}
+
+	void raised(int & fixup) {
+		fixup = total_frames + 42;						// use local scope => lexical link
+	}
+
+	Time start_time = timeHiRes();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		nounwind_fixup(total_frames, raised);
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-empty-r.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-empty-r.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-empty-r.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,41 @@
+// Resume Across Empty Function
+#include <clock.hfa>
+#include <exception.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+exception fixup_exception {
+	int & fixup;
+};
+vtable(fixup_exception) fixup_vt;
+
+void nounwind_empty(unsigned int frames) {
+	if (frames) {
+		nounwind_empty(frames - 1);
+	} else {
+		int fixup = 17;
+		throwResume (fixup_exception){&fixup_vt, fixup}; // change bad fixup
+	}
+}
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+	if (2 < argc) {
+		total_frames = strto(argv[2], 0p, 10);
+	}
+
+	Time start_time = timeHiRes();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		try {
+			nounwind_empty(total_frames);
+		} catchResume (fixup_exception * ex) {
+			ex->fixup = total_frames + 42;
+		}
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-empty.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-empty.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-empty.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,41 @@
+// Resume Across Fixup
+#include <chrono>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <iomanip>
+#include <functional>
+
+using namespace std;
+using namespace chrono;
+
+void nounwind_fixup(unsigned int frames, function<void (int &)> raised_rtn ) {
+	if (frames) {
+		nounwind_fixup(frames - 1, raised_rtn);
+	} else {
+		int fixup = 17;
+		raised_rtn(fixup);
+	}
+}
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strtol(argv[1], nullptr, 10);
+	}
+	if (2 < argc) {
+		total_frames = strtol(argv[2], nullptr, 10);
+	}
+
+	auto raised = [=] (int & fixup) -> void {
+					  fixup = total_frames + 42;		// use local scope => lexical link
+				  };
+	time_point<steady_clock> start_time = steady_clock::now();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		nounwind_fixup(total_frames, raised);
+	}
+	time_point<steady_clock> end_time = steady_clock::now();
+	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
+}
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-empty.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-empty.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-empty.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+from time import thread_time_ns
+
+def nounwind_fixup(frames, raised_rtn):
+    if 0 < frames:
+        nounwind_fixup(frames - 1, raised_rtn)
+    else:
+        fixup = 17;
+        raised_rtn(fixup);
+
+
+def main(argv):
+    times = 1
+    total_frames = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    raised = lambda lfixup : total_frames + 42		# use local scope => lexical link
+    start_time = thread_time_ns()
+    for count in range(times):
+        nounwind_fixup(total_frames, raised)
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-other-f.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-other-f.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-other-f.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,46 @@
+// Resume Across Fixup
+#include <clock.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+unsigned int frames;									// use global because of gcc thunk problem
+
+void nounwind_fixup(unsigned int dummy, void (*raised_rtn)(int &), void (*not_raised_rtn)(int &)) {
+	void not_raised(int & fixup) {
+		fixup = frames + 42;							// use local scope => lexical link
+	}
+
+	if (frames) {
+		frames -= 1;
+		nounwind_fixup(42, raised_rtn, not_raised);
+	} else {
+		int fixup = dummy;
+		raised_rtn(fixup);
+	}
+}
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+	if (2 < argc) {
+		total_frames = strto(argv[2], 0p, 10);
+	}
+	frames = total_frames;
+
+	void raised(int & fixup) {
+		fixup = total_frames + 42;						// use local scope => lexical link
+	}
+	void not_raised(int & fixup) {
+		fixup = total_frames + 42;						// use local scope => lexical link
+	}
+
+	Time start_time = timeHiRes();
+	for (int count = 0 ; count < times ; ++count) {
+		nounwind_fixup(42, raised, not_raised);
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-other-r.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-other-r.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-other-r.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,52 @@
+// Resume Across Other Handler
+#include <clock.hfa>
+#include <exception.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+exception fixup_exception {
+	int & fixup;
+};
+vtable(fixup_exception) fixup_vt;
+exception not_raised_exception {
+	int & fixup;
+};
+
+unsigned int frames;									// use global because of gcc thunk problem
+
+void nounwind_other(unsigned int dummy) {
+	if (frames) {
+		frames -= 1;
+		try {
+			nounwind_other(42);
+		} catchResume (not_raised_exception * ex) {
+			ex->fixup = frames + 42;					// use local scope => lexical link
+		}
+	} else {
+		int fixup = dummy;
+		throwResume (fixup_exception){&fixup_vt, fixup}; // change bad fixup
+	}
+}
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+	if (2 < argc) {
+		total_frames = strto(argv[2], 0p, 10);
+	}
+	frames = total_frames;
+
+	Time start_time = timeHiRes();
+	for (int count = 0 ; count < times ; ++count) {
+		try {
+			nounwind_other(42);
+		} catchResume (fixup_exception * ex) {
+			ex->fixup = total_frames + 42;
+		}
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-other.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-other.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-other.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,49 @@
+// Resume Across Fixup
+#include <chrono>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <iomanip>
+#include <functional>
+
+using namespace std;
+using namespace chrono;
+
+void nounwind_fixup(unsigned int frames, function<void (int &)> raised_rtn, function<void (int &)> not_raised_rtn ) {
+	auto not_raised = [=](int & fixup) -> void {
+						  fixup = frames + 42;			// use local scope => lexical link
+					  };
+
+	if (frames) {
+		nounwind_fixup(frames - 1, raised_rtn, not_raised);
+	} else {
+		int fixup = 17;
+		raised_rtn(fixup);
+	}
+}
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strtol(argv[1], nullptr, 10);
+	}
+	if (2 < argc) {
+		total_frames = strtol(argv[2], nullptr, 10);
+	}
+
+	auto raised = [=] (int & fixup) -> void {
+					  fixup = total_frames + 42;		// use local scope => lexical link
+				  };
+	auto not_raised = [=] (int & fixup) -> void {
+						  fixup = total_frames + 42;	// use local scope => lexical link
+					  };
+
+	time_point<steady_clock> start_time = steady_clock::now();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		nounwind_fixup(total_frames, raised, not_raised);
+	}
+	time_point<steady_clock> end_time = steady_clock::now();
+	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
+}
Index: doc/theses/andrew_beach_MMath/code/resume-fixup-other.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-fixup-other.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/resume-fixup-other.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+from time import thread_time_ns
+
+def nounwind_fixup(frames, raised_rtn, not_raised_rtn):
+    not_raised = lambda lfixup : frames + 42		# use local scope => lexical link
+    if 0 < frames:
+        nounwind_fixup(frames - 1, raised_rtn, not_raised)
+    else:
+        fixup = 17;
+        raised_rtn(fixup);
+
+
+def main(argv):
+    times = 1
+    total_frames = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    raised = lambda lfixup : total_frames + 42		# use local scope => lexical link
+    not_raised = lambda lfixup : total_frames + 42	# use local scope => lexical link
+    start_time = thread_time_ns()
+    for count in range(times):
+        nounwind_fixup(total_frames, raised, not_raised)
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/resume-other.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/resume-other.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/resume-other.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,16 +3,14 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
+exception empty_exception;
+vtable(empty_exception) empty_vt;
+exception not_raised_exception;
 
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
-
-EHM_EXCEPTION(not_raised_exception)();
-
-void unwind_other(unsigned int frames) {
+void nounwind_other(unsigned int frames) {
 	if (frames) {
 		try {
-			unwind_other(frames - 1);
+			nounwind_other(frames - 1);
 		} catchResume (not_raised_exception *) {
 			asm volatile ("# fixup block (stack)");
@@ -27,8 +25,8 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
 
@@ -36,5 +34,5 @@
 	for (int count = 0 ; count < times ; ++count) {
 		try {
-			unwind_other(total_frames);
+			nounwind_other(total_frames);
 		} catchResume (empty_exception *) {
 			asm volatile ("# fixup block (base)");
@@ -42,4 +40,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/run.sh
===================================================================
--- doc/theses/andrew_beach_MMath/code/run.sh	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/run.sh	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-readonly ALL_TESTS=(cond-match-{all,none} cross-{catch,finally} \
-		raise-{detor,empty,finally,other})
+readonly ALL_TESTS=(raise-{empty,detor,finally,other} try-{catch,finally} cond-match-{all,none} \
+		    raise-{fixup-empty,fixup-other})
 
 gen-file-name() (
@@ -18,5 +18,6 @@
 )
 
-readonly N=${1:-5}
+#readonly N=${1:-5}
+readonly N=${1:-1}
 readonly OUT_FILE=$(gen-file-name ${2:-run-%-$N})
 
Index: doc/theses/andrew_beach_MMath/code/test.sh
===================================================================
--- doc/theses/andrew_beach_MMath/code/test.sh	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/test.sh	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -4,10 +4,17 @@
 # test.sh LANGUAGE TEST
 #   Run the TEST in LANGUAGE.
+# test.sh -a
+#   Build all tests.
 # test.sh -b SOURCE_FILE...
 #   Build a test from SOURCE_FILE(s).
+# test.sh -c
+#   Clean all executables.
 # test.sh -v LANGUAGE TEST FILE
 #   View the result from TEST in LANGUAGE stored in FILE.
 
-readonly ITERATIONS=1000000 # 1 000 000, one million
+readonly ITERS_1M=1000000 # 1 000 000, one million
+readonly ITERS_10M=10000000 # 10 000 000, ten million
+readonly ITERS_100M=100000000 # 100 000 000, hundred million
+readonly ITERS_1000M=1000000000 # 1 000 000 000, billion
 readonly STACK_HEIGHT=100
 
@@ -24,8 +31,8 @@
 	*.cfa)
 		# Requires a symbolic link.
-		mmake "${1%.cfa}" "$1" ./cfa -DNDEBUG -nodebug -O3 "$1" -o "${1%.cfa}"
+		mmake "${1%.cfa}" "$1" cfa -DNDEBUG -nodebug -O3 "$1" -o "${1%.cfa}"
 		;;
 	*.cpp)
-		mmake "${1%.cpp}-cpp" "$1" g++ -DNDEBUG -O3 "$1" -o "${1%.cpp}-cpp"
+		mmake "${1%.cpp}-cpp" "$1" g++-10 -DNDEBUG -O3 "$1" -o "${1%.cpp}-cpp"
 		;;
 	*.java)
@@ -39,13 +46,24 @@
 )
 
-if [ "-b" = "$1" ]; then
+if [ "-a" = "$1" ]; then			# build all
+	for file in *.cfa *.cpp *.java; do
+		build $file
+	done
+	exit 0
+elif [ "-b" = "$1" ]; then			# build given
 	for file in "${@:2}"; do
 		build $file
 	done
 	exit 0
+elif [ "-c" = "$1" ]; then			# clean all
+	rm -f `basename -s ".cfa" -a *.cfa`
+	rm -f `basename -s ".cpp" -a *.cpp`
+	rm -f *-cpp
+	rm -f *.class
+	exit 0
 elif [ "-v" = "$1" -a 4 = "$#" ]; then
-    TEST_LANG="$2"
-    TEST_CASE="$3"
-    VIEW_FILE="$4"
+	TEST_LANG="$2"
+	TEST_CASE="$3"
+	VIEW_FILE="$4"
 elif [ 2 -eq "$#" ]; then
 	TEST_LANG="$1"
@@ -63,59 +81,73 @@
 
 case "$TEST_CASE" in
-cond-match-all)
-	CFAT="./cond-catch $ITERATIONS 1"
-	CFAR="./cond-fixup $ITERATIONS 1"
-	CPP="./cond-catch-cpp $ITERATIONS 1"
-	JAVA="java CondCatch $ITERATIONS 1"
-	PYTHON="./cond_catch.py $ITERATIONS 1"
-	;;
-cond-match-none)
-	CFAT="./cond-catch $ITERATIONS 0"
-	CFAR="./cond-fixup $ITERATIONS 0"
-	CPP="./cond-catch-cpp $ITERATIONS 0"
-	JAVA="java CondCatch $ITERATIONS 0"
-	PYTHON="./cond_catch.py $ITERATIONS 0"
-	;;
-cross-catch)
-	CFAT="./cross-catch $ITERATIONS"
-	CFAR="./cross-resume $ITERATIONS"
-	CPP="./cross-catch-cpp $ITERATIONS"
-	JAVA="java CrossCatch $ITERATIONS"
-	PYTHON="./cross_catch.py $ITERATIONS"
-	;;
-cross-finally)
-	CFAT="./cross-finally $ITERATIONS"
-	CFAR=unsupported
-	CPP=unsupported
-	JAVA="java CrossFinally $ITERATIONS"
-	PYTHON="./cross_finally.py $ITERATIONS"
+raise-empty)
+	CFAT="./throw-empty $ITERS_1M $STACK_HEIGHT"
+# see resume-fixup-empty-r	CFAR="./resume-empty $ITERS_1M $STACK_HEIGHT"
+	CPP="./throw-empty-cpp $ITERS_1M $STACK_HEIGHT"
+	JAVA="java ThrowEmpty $ITERS_1M $STACK_HEIGHT"
+	PYTHON="./throw-empty.py $ITERS_1M $STACK_HEIGHT"
 	;;
 raise-detor)
-	CFAT="./throw-detor $ITERATIONS $STACK_HEIGHT"
-	CFAR="./resume-detor $ITERATIONS $STACK_HEIGHT"
-	CPP="./throw-detor-cpp $ITERATIONS $STACK_HEIGHT"
+	CFAT="./throw-detor $ITERS_1M $STACK_HEIGHT"
+# N/A	CFAR="./resume-detor $ITERS_1M $STACK_HEIGHT"
+	CPP="./throw-detor-cpp $ITERS_1M $STACK_HEIGHT"
 	JAVA=unsupported
 	PYTHON=unsupported
 	;;
-raise-empty)
-	CFAT="./throw-empty $ITERATIONS $STACK_HEIGHT"
-	CFAR="./resume-empty $ITERATIONS $STACK_HEIGHT"
-	CPP="./throw-empty-cpp $ITERATIONS $STACK_HEIGHT"
-	JAVA="java ThrowEmpty $ITERATIONS $STACK_HEIGHT"
-	PYTHON="./throw_empty.py $ITERATIONS $STACK_HEIGHT"
-	;;
 raise-finally)
-	CFAT="./throw-finally $ITERATIONS $STACK_HEIGHT"
-	CFAR="./resume-finally $ITERATIONS $STACK_HEIGHT"
+	CFAT="./throw-finally $ITERS_1M $STACK_HEIGHT"
+# N/A	CFAR="./resume-finally $ITERS_1M $STACK_HEIGHT"
 	CPP=unsupported
-	JAVA="java ThrowFinally $ITERATIONS $STACK_HEIGHT"
-	PYTHON="./throw_finally.py $ITERATIONS $STACK_HEIGHT"
+	JAVA="java ThrowFinally $ITERS_1M $STACK_HEIGHT"
+	PYTHON="./throw-finally.py $ITERS_1M $STACK_HEIGHT"
 	;;
 raise-other)
-	CFAT="./throw-other $ITERATIONS $STACK_HEIGHT"
-	CFAR="./resume-other $ITERATIONS $STACK_HEIGHT"
-	CPP="./throw-other-cpp $ITERATIONS $STACK_HEIGHT"
-	JAVA="java ThrowOther $ITERATIONS $STACK_HEIGHT"
-	PYTHON="./throw_other.py $ITERATIONS $STACK_HEIGHT"
+	CFAT="./throw-other $ITERS_1M $STACK_HEIGHT"
+# N/A	CFAR="./resume-other $ITERS_1M $STACK_HEIGHT"
+	CPP="./throw-other-cpp $ITERS_1M $STACK_HEIGHT"
+	JAVA="java ThrowOther $ITERS_1M $STACK_HEIGHT"
+	PYTHON="./throw-other.py $ITERS_1M $STACK_HEIGHT"
+	;;
+try-catch)
+	CFAT="./try-catch $ITERS_1000M"
+	CFAR="./try-resume $ITERS_1000M"
+	CPP="./try-catch-cpp $ITERS_1000M"
+	JAVA="java TryCatch $ITERS_1000M"
+	PYTHON="./try-catch.py $ITERS_1000M"
+	;;
+try-finally)
+	CFAT="./try-finally $ITERS_1000M"
+	CFAR=unsupported
+	CPP=unsupported
+	JAVA="java TryFinally $ITERS_1000M"
+	PYTHON="./try-finally.py $ITERS_1000M"
+	;;
+cond-match-all)
+	CFAT="./cond-catch $ITERS_10M 1"
+	CFAR="./cond-fixup $ITERS_10M 1"
+	CPP="./cond-catch-cpp $ITERS_10M 1"
+	JAVA="java CondCatch $ITERS_10M 1"
+	PYTHON="./cond-catch.py $ITERS_10M 1"
+	;;
+cond-match-none)
+	CFAT="./cond-catch $ITERS_10M 0"
+	CFAR="./cond-fixup $ITERS_10M 0"
+	CPP="./cond-catch-cpp $ITERS_10M 0"
+	JAVA="java CondCatch $ITERS_10M 0"
+	PYTHON="./cond-catch.py $ITERS_10M 0"
+	;;
+raise-fixup-empty)
+	CFAT="./resume-fixup-empty-f $ITERS_10M $STACK_HEIGHT"
+	CFAR="./resume-fixup-empty-r $ITERS_10M $STACK_HEIGHT"
+	CPP="./resume-fixup-empty-cpp $ITERS_10M $STACK_HEIGHT"
+	JAVA="java ResumeFixupEmpty $ITERS_10M $STACK_HEIGHT"
+	PYTHON="./resume-fixup-empty.py $ITERS_10M $STACK_HEIGHT"
+	;;
+raise-fixup-other)
+	CFAT="./resume-fixup-other-f $ITERS_10M $STACK_HEIGHT"
+	CFAR="./resume-fixup-other-r $ITERS_10M $STACK_HEIGHT"
+	CPP="./resume-fixup-other-cpp $ITERS_10M $STACK_HEIGHT"
+	JAVA="java ResumeFixupOther $ITERS_10M $STACK_HEIGHT"
+	PYTHON="./resume-fixup-other.py $ITERS_10M $STACK_HEIGHT"
 	;;
 *)
@@ -126,12 +158,12 @@
 
 case "$TEST_LANG" in
-cfa-t) CALL="$CFAT";;
-cfa-r) CALL="$CFAR";;
-cpp) CALL="$CPP";;
-java) CALL="$JAVA";;
-python) CALL="$PYTHON";;
-*)
-	echo "No such language: $TEST_LANG" >&2
-	exit 2
+	cfa-t) CALL="$CFAT";;
+	cfa-r) CALL="$CFAR";;
+	cpp) CALL="$CPP";;
+	java) CALL="$JAVA";;
+	python) CALL="$PYTHON";;
+	*)
+		echo "No such language: $TEST_LANG" >&2
+		exit 2
 	;;
 esac
@@ -140,6 +172,6 @@
 
 if [ -n "$VIEW_FILE" ]; then
-    grep -A 1 -B 0 "$CALL" "$VIEW_FILE" | sed -n -e 's!Run-Time (ns): !!;T;p'
-    exit
+	grep -A 1 -B 0 "$CALL" "$VIEW_FILE" | sed -n -e 's!Run-Time (ns): !!;T;p'
+	exit
 fi
 
Index: doc/theses/andrew_beach_MMath/code/throw-detor.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-detor.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-detor.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,9 +3,8 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
-
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
 struct WithDestructor {};
@@ -28,8 +27,8 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
 
@@ -43,4 +42,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/throw-detor.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-detor.cpp	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-detor.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -4,5 +4,7 @@
 #include <exception>
 #include <iostream>
+#include <iomanip>
 
+using namespace std;
 using namespace std::chrono;
 
@@ -44,4 +46,4 @@
 	time_point<steady_clock> end_time = steady_clock::now();
 	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
-	std::cout << "Run-Time (ns): " << duration.count() << std::endl;
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
 }
Index: doc/theses/andrew_beach_MMath/code/throw-empty.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-empty.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-empty.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,9 +3,8 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
-
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
 void unwind_empty(unsigned int frames) {
@@ -21,8 +20,8 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
 
@@ -36,4 +35,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/throw-empty.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-empty.cpp	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-empty.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -4,5 +4,7 @@
 #include <exception>
 #include <iostream>
+#include <iomanip>
 
+using namespace std;
 using namespace std::chrono;
 
@@ -37,4 +39,4 @@
 	time_point<steady_clock> end_time = steady_clock::now();
 	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
-	std::cout << "Run-Time (ns): " << duration.count() << std::endl;
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
 }
Index: doc/theses/andrew_beach_MMath/code/throw-empty.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-empty.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/throw-empty.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+
+# Throw Across Empty Function
+
+from time import thread_time_ns
+
+
+class EmptyException(Exception):
+    pass
+
+
+def unwind_empty(frames):
+    if 0 < frames:
+        unwind_empty(frames - 1)
+    else:
+        raise EmptyException()
+
+
+def main(argv):
+    times = 1
+    total_frames = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            unwind_empty(total_frames)
+        except EmptyException:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw-finally.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-finally.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-finally.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,18 +3,21 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
+exception empty_exception;
+vtable(empty_exception) empty_vt;
 
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+unsigned int frames;									// use global because of gcc thunk problem
 
-void unwind_finally(unsigned int frames) {
+void unwind_finally(unsigned int dummy) {
 	if (frames) {
+		frames -= 1;
 		try {
-			unwind_finally(frames - 1);
+			unwind_finally(42);
 		} finally {
 			asm volatile ("# finally block");
 		}
 	} else {
+		dummy = 42;
 		throw (empty_exception){&empty_vt};
 	}
@@ -25,14 +28,15 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
+	frames = total_frames;
 
 	Time start_time = timeHiRes();
 	for (int count = 0 ; count < times ; ++count) {
 		try {
-			unwind_finally(total_frames);
+			unwind_finally(42);
 		} catch (empty_exception *) {
 			asm volatile ("# catch block");
@@ -40,4 +44,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/throw-finally.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-finally.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/throw-finally.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+# Throw Across Finally
+
+from time import thread_time_ns
+
+
+class EmptyException(Exception):
+    pass
+
+
+def unwind_finally(frames):
+    if 0 < frames:
+        try:
+            unwind_finally(frames - 1)
+        finally:
+            pass
+    else:
+        raise EmptyException()
+
+
+def main(argv):
+    times = 1
+    total_frames = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            unwind_finally(total_frames)
+        except EmptyException:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw-other.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-other.cfa	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-other.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -3,20 +3,22 @@
 #include <exception.hfa>
 #include <fstream.hfa>
-#include <stdlib.hfa>
+#include <stdlib.hfa>									// strto
 
-EHM_EXCEPTION(empty_exception)();
+exception empty_exception;
+vtable(empty_exception) empty_vt;
+exception not_raised_exception;
 
-EHM_VIRTUAL_TABLE(empty_exception, empty_vt);
+unsigned int frames;									// use global because of gcc thunk problem
 
-EHM_EXCEPTION(not_raised_exception)();
-
-void unwind_other(unsigned int frames) {
+void unwind_other(unsigned int dummy) {
 	if (frames) {
+		frames -= 1;
 		try {
-			unwind_other(frames - 1);
+			unwind_other(42);
 		} catch (not_raised_exception *) {
 			asm volatile ("# catch block (stack)");
 		}
 	} else {
+		dummy = 42;
 		throw (empty_exception){&empty_vt};
 	}
@@ -27,14 +29,15 @@
 	unsigned int total_frames = 1;
 	if (1 < argc) {
-		times = strtol(argv[1], 0p, 10);
+		times = strto(argv[1], 0p, 10);
 	}
 	if (2 < argc) {
-		total_frames = strtol(argv[2], 0p, 10);
+		total_frames = strto(argv[2], 0p, 10);
 	}
+	frames = total_frames;
 
 	Time start_time = timeHiRes();
 	for (int count = 0 ; count < times ; ++count) {
 		try {
-			unwind_other(total_frames);
+			unwind_other(42);
 		} catch (empty_exception *) {
 			asm volatile ("# catch block (base)");
@@ -42,4 +45,4 @@
 	}
 	Time end_time = timeHiRes();
-	sout | "Run-Time (ns): " | (end_time - start_time)`ns;
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
 }
Index: doc/theses/andrew_beach_MMath/code/throw-other.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-other.cpp	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ doc/theses/andrew_beach_MMath/code/throw-other.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -4,5 +4,7 @@
 #include <exception>
 #include <iostream>
+#include <iomanip>
 
+using namespace std;
 using namespace std::chrono;
 
@@ -43,4 +45,4 @@
 	time_point<steady_clock> end_time = steady_clock::now();
 	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
-	std::cout << "Run-Time (ns): " << duration.count() << std::endl;
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
 }
Index: doc/theses/andrew_beach_MMath/code/throw-other.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-other.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/throw-other.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+
+# Throw Across Other Handler
+
+from time import thread_time_ns
+
+
+class EmptyException(Exception):
+    pass
+
+
+class NotRaisedException(Exception):
+    pass
+
+
+def unwind_other(frames):
+    if 0 < frames:
+        try:
+            unwind_other(frames - 1)
+        except NotRaisedException:
+            pass
+    else:
+        raise EmptyException()
+
+
+def main(argv):
+    times = 1
+    total_frames = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            unwind_other(total_frames)
+        except EmptyException:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw-with.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw-with.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/throw-with.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+
+# Throw Across With Statement (closest thing Python has to a destructor)
+
+from time import thread_time_ns
+
+
+class EmptyException(Exception):
+    pass
+
+
+class EmptyContextManager:
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        pass
+
+
+def unwind_with(frames):
+    if 0 < frames:
+        with EmptyContextManager():
+            unwind_with(frames - 1)
+    else:
+        raise EmptyException()
+
+
+def main(argv):
+    times = 1
+    total_frames = 1
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            unwind_with(total_frames)
+        except EmptyException:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw_empty.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw_empty.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,40 +1,0 @@
-#!/usr/bin/env python3
-
-# Throw Across Empty Function
-
-from time import thread_time_ns
-
-
-class EmptyException(Exception):
-    pass
-
-
-def unwind_empty(frames):
-    if 0 < frames:
-        unwind_empty(frames - 1)
-    else:
-        raise EmptyException()
-
-
-def main(argv):
-    times = 1
-    total_frames = 1
-    if 1 < len(argv):
-        times = int(argv[1])
-    if 2 < len(argv):
-        total_frames = int(argv[2])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            unwind_empty(total_frames)
-        except EmptyException:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw_finally.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw_finally.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,43 +1,0 @@
-#!/usr/bin/env python3
-
-# Throw Across Finally
-
-from time import thread_time_ns
-
-
-class EmptyException(Exception):
-    pass
-
-
-def unwind_finally(frames):
-    if 0 < frames:
-        try:
-            unwind_finally(frames - 1)
-        finally:
-            pass
-    else:
-        raise EmptyException()
-
-
-def main(argv):
-    times = 1
-    total_frames = 1
-    if 1 < len(argv):
-        times = int(argv[1])
-    if 2 < len(argv):
-        total_frames = int(argv[2])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            unwind_finally(total_frames)
-        except EmptyException:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw_other.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw_other.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,47 +1,0 @@
-#!/usr/bin/env python3
-
-# Throw Across Other Handler
-
-from time import thread_time_ns
-
-
-class EmptyException(Exception):
-    pass
-
-
-class NotRaisedException(Exception):
-    pass
-
-
-def unwind_other(frames):
-    if 0 < frames:
-        try:
-            unwind_other(frames - 1)
-        except NotRaisedException:
-            pass
-    else:
-        raise EmptyException()
-
-
-def main(argv):
-    times = 1
-    total_frames = 1
-    if 1 < len(argv):
-        times = int(argv[1])
-    if 2 < len(argv):
-        total_frames = int(argv[2])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            unwind_other(total_frames)
-        except EmptyException:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/throw_with.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/throw_with.py	(revision 9a3a3130629b661ca7717a58f18556e40c476031)
+++ 	(revision )
@@ -1,50 +1,0 @@
-#!/usr/bin/env python3
-
-# Throw Across With Statement (closest thing Python has to a destructor)
-
-from time import thread_time_ns
-
-
-class EmptyException(Exception):
-    pass
-
-
-class EmptyContextManager:
-
-    def __enter__(self):
-        pass
-
-    def __exit__(self, exception_type, exception_value, traceback):
-        pass
-
-
-def unwind_with(frames):
-    if 0 < frames:
-        with EmptyContextManager():
-            unwind_with(frames - 1)
-    else:
-        raise EmptyException()
-
-
-def main(argv):
-    times = 1
-    total_frames = 1
-    if 1 < len(argv):
-        times = int(argv[1])
-    if 2 < len(argv):
-        total_frames = int(argv[2])
-
-    start_time = thread_time_ns()
-    for count in range(times):
-        try:
-            unwind_with(total_frames)
-        except EmptyException:
-            pass
-
-    end_time = thread_time_ns()
-    print('Run-Time (ns):', end_time - start_time)
-
-
-if '__main__' == __name__:
-    import sys
-    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/try-catch.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/try-catch.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/try-catch.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,30 @@
+// Cross a Try Statement with a Termination Handler
+#include <clock.hfa>
+#include <exception.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+exception not_raised_exception;
+vtable(not_raised_exception) not_vt;
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	volatile bool should_throw = false;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+
+	Time start_time = timeHiRes();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		try {
+			asm volatile ("# try block");
+			if (should_throw) {
+				throw (not_raised_exception){&not_vt};
+			}
+		} catch (not_raised_exception *) {
+			asm volatile ("# catch block");
+		}
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}
Index: doc/theses/andrew_beach_MMath/code/try-catch.cpp
===================================================================
--- doc/theses/andrew_beach_MMath/code/try-catch.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/try-catch.cpp	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,34 @@
+// Cross a Try Statement with a Termination Handler
+#include <chrono>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+using namespace std::chrono;
+
+struct NotRaisedException : public std::exception {};
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	volatile bool should_throw = false;
+	if (1 < argc) {
+		times = strtol(argv[1], nullptr, 10);
+	}
+
+	time_point<steady_clock> start_time = steady_clock::now();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		try {
+			asm volatile ("# try block");
+			if (should_throw) {
+				throw NotRaisedException();
+			}
+		} catch (NotRaisedException &) {
+			asm volatile ("# catch block");
+		}
+	}
+	time_point<steady_clock> end_time = steady_clock::now();
+	nanoseconds duration = duration_cast<nanoseconds>(end_time - start_time);
+	cout << "Run-Time (s): " << fixed << setprecision(1) << duration.count() / 1'000'000'000. << endl;
+}
Index: doc/theses/andrew_beach_MMath/code/try-catch.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/try-catch.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/try-catch.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+# Cross a Try Statement with a Termination Handler
+
+from time import thread_time_ns
+
+
+class NotRaisedException(Exception):
+    pass
+
+
+def main(argv):
+    times = 1;
+    if 1 < len(argv):
+        times = int(argv[1])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            pass
+        except NotRaisedException:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/try-finally.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/try-finally.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/try-finally.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,30 @@
+// Cross a Try Statement With Finally Clause
+#include <clock.hfa>
+#include <exception.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+exception not_raised_exception;
+vtable(not_raised_exception) not_vt;
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	volatile bool should_throw = false;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+
+	Time start_time = timeHiRes();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		try {
+			asm volatile ("# try block");
+			if (should_throw) {
+				throw (not_raised_exception){&not_vt};
+			}
+		} finally {
+			asm volatile ("# finally block");
+		}
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}
Index: doc/theses/andrew_beach_MMath/code/try-finally.py
===================================================================
--- doc/theses/andrew_beach_MMath/code/try-finally.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/try-finally.py	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+# Cross a Try Statement With Finally Clause
+
+from time import thread_time_ns
+
+
+def main(argv):
+    times = 1;
+    total_frames = 1;
+    if 1 < len(argv):
+        times = int(argv[1])
+    if 2 < len(argv):
+        total_frames = int(argv[2])
+
+    start_time = thread_time_ns()
+    for count in range(times):
+        try:
+            pass
+        finally:
+            pass
+
+    end_time = thread_time_ns()
+    print('Run-Time (s) {:.1f}:'.format((end_time - start_time) / 1_000_000_000.))
+
+
+if '__main__' == __name__:
+    import sys
+    main(sys.argv)
Index: doc/theses/andrew_beach_MMath/code/try-resume.cfa
===================================================================
--- doc/theses/andrew_beach_MMath/code/try-resume.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
+++ doc/theses/andrew_beach_MMath/code/try-resume.cfa	(revision 315e5e373412e790b084d3570db5755620ef6682)
@@ -0,0 +1,29 @@
+// Cross a Try Statement With Finally Clause
+#include <clock.hfa>
+#include <exception.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>									// strto
+
+exception not_raised_exception;
+
+int main(int argc, char * argv[]) {
+	unsigned int times = 1;
+	unsigned int total_frames = 1;
+	if (1 < argc) {
+		times = strto(argv[1], 0p, 10);
+	}
+	if (2 < argc) {
+		total_frames = strto(argv[2], 0p, 10);
+	}
+
+	Time start_time = timeHiRes();
+	for (unsigned int count = 0 ; count < times ; ++count) {
+		try {
+			asm volatile ("");
+		} catchResume (not_raised_exception *) {
+			asm volatile ("");
+		}
+	}
+	Time end_time = timeHiRes();
+	sout | "Run-Time (s): " | wd(0,1, (end_time - start_time)`ns / 1_000_000_000.);
+}