Split from ch25, SCCP and interprocedural SCCPmain

83 files changed, 14141 insertions, 0 deletions

diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/BrainFuckTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
new file mode 100644
index 00000000..a3b98fe0
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
@@ -0,0 +1,89 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class BrainFuckTest {
+
+    @Test public void testBrainFuck() throws IOException {
+        String brain_fuck = "Hello World!\n";
+        String src =
+"""
+// -*- mode: java;  -*-
+val brain_fuck = { ->
+    var !program = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.";
+    int d = 0;
+    u8[] !output = new u8[0];
+    u8[] !data = new u8[100];
+
+    for( int pc = 0; pc < program#; pc++ ) {
+        var command = program[pc];
+        if (command == 62) {
+            d++;
+        } else if (command == 60) {
+            d--;
+        } else if (command == 43) {
+            data[d]++;
+        } else if (command == 45) {
+            data[d]--;
+        } else if (command == 46) {
+            // Output a byte; increase the output array size
+            var old = output;
+            output = new u8[output# + 1];
+            for( int i = 0; i < old#; i++ )
+                output[i] = old[i];
+            output[old#] = data[d]; // Add the extra byte on the end
+        } else if (command == 44) {
+            data[d] = 42;
+        } else if (command == 91) {
+            if (data[d] == 0) {
+                for( int d = 1; d > 0; ) {
+                    command = program[++pc];
+                    if (command == 91) d++;
+                    if (command == 93) d--;
+                }
+            }
+        } else if (command == 93) {
+            if (data[d]) {
+                for( int d = 1; d > 0; ) {
+                    command = program[--pc];
+                    if (command == 93) d++;
+                    if (command == 91) d--;
+                }
+            }
+        }
+    }
+    return output;
+};
+""";
+        TestC.run(src,"brain_fuck", null, brain_fuck, 40);
+
+        EvalRisc5 R5 = TestRisc5.build("brain_fuck", src, 0, 28, false);
+        int trap = R5.step(100000);
+        assertEquals(0,trap);
+        int ptr = (int)R5.regs[com.seaofnodes.simple.node.cpus.riscv.riscv.A0];
+        assertEquals(brain_fuck.length(),R5.ld4s(ptr));
+        for( int i=0; i<brain_fuck.length(); i++ )
+            assertEquals(brain_fuck.charAt(i), R5.ld1z(ptr+4+i));
+
+        EvalArm64 A5 = TestArm64.build("brain_fuck", src, 0, 28, false);
+        int trap_arm = A5.step(100000);
+        assertEquals(0,trap_arm);
+        assertEquals(0,trap);
+        int ptr_arm = (int)A5.regs[com.seaofnodes.simple.node.cpus.arm.arm.X0];
+        assertEquals(brain_fuck.length(),A5.ld4s(ptr_arm));
+
+        for( int i=0; i<brain_fuck.length(); i++ )
+            assertEquals(brain_fuck.charAt(i), A5.ld1z(ptr_arm+4+i));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter01Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter01Test.java
new file mode 100644
index 00000000..ac9adacc
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter01Test.java
@@ -0,0 +1,95 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter01Test {
+
+    @Test
+    public void testSimpleProgram() {
+        CodeGen code = new CodeGen("return 1;").parse();
+        Node expr = code.expr();
+        if( expr instanceof ConstantNode con ) {
+            assertEquals(code._start,con.in(0));
+            assertEquals(TypeInteger.constant(1), con._type);
+        } else {
+            fail();
+        }
+    }
+
+    @Test
+    public void testZero() {
+        CodeGen code = new CodeGen("return 0;");
+        code.parse();
+        Node use = code.expr();
+        if( use instanceof ConstantNode con && con._type instanceof TypeInteger )
+            assertEquals(TypeInteger.constant(0),con._type);
+    }
+
+    @Test
+    public void testBad1() {
+        try {
+            new CodeGen("ret;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'ret'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBad2() {
+        try {
+            new CodeGen("return 0123;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Syntax error: integer values cannot start with '0'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testNotBad3() {
+        // this test used to fail in chapter 1
+        assertEquals("return 12;", new CodeGen("return - -12;").parse()._stop.print());
+    }
+
+    @Test
+    public void testBad4() {
+        try {
+            new CodeGen("return 100").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Syntax error, expected ;: ",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testNotBad5() {
+        // this test used to fail in chapter 1
+        assertEquals("return -100;", new CodeGen("return -100;").parse()._stop.print());
+    }
+
+    @Test
+    public void testBad6() {
+        try {
+            new CodeGen("return100;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'return100'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBad7() {
+        try {
+            new CodeGen("return 1;}").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Syntax error, unexpected: }",e.getMessage());
+        }
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter02Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter02Test.java
new file mode 100644
index 00000000..a51ac202
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter02Test.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter02Test {
+
+    @Test
+    public void testParseGrammar() {
+        CodeGen code = new CodeGen("return 1+2*3+-5;");
+        code.parse();
+        assertEquals("return 2;", code.print());
+    }
+
+    @Test
+    public void testAddPeephole() {
+        CodeGen code = new CodeGen("return 1+2;");
+        code.parse();
+        assertEquals("return 3;", code.print());
+    }
+
+    @Test
+    public void testSubPeephole() {
+        CodeGen code = new CodeGen("return 1-2;");
+        code.parse();
+        assertEquals("return -1;", code.print());
+    }
+
+    @Test
+    public void testMulPeephole() {
+        CodeGen code = new CodeGen("return 2*3;");
+        code.parse();
+        assertEquals("return 6;", code.print());
+    }
+
+    @Test
+    public void testDivPeephole() {
+        CodeGen code = new CodeGen("return 6/3;");
+        code.parse();
+        assertEquals("return 2;", code.print());
+    }
+
+    @Test
+    public void testMinusPeephole() {
+        CodeGen code = new CodeGen("return 6/-3;");
+        code.parse();
+        assertEquals("return -2;", code.print());
+    }
+
+    @Test
+    public void testExample() {
+        CodeGen code = new CodeGen("return 1+2*3+-5;");
+        code.parse();
+        assertEquals("return 2;", code.print());
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter03Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter03Test.java
new file mode 100644
index 00000000..8923566a
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter03Test.java
@@ -0,0 +1,66 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter03Test {
+
+    @Test
+    public void testVarDecl() {
+        CodeGen code = new CodeGen("int a=1; return a;");
+        code.parse(); assertEquals("return 1;", code.print());
+    }
+
+    @Test
+    public void testVarAdd() {
+        CodeGen code = new CodeGen("int a=1; int b=2; return a+b;");
+        code.parse();
+        assertEquals("return 3;", code.print());
+    }
+
+    @Test
+    public void testVarScope() {
+        CodeGen code = new CodeGen("int a=1; int b=2; int c=0; { int b=3; c=a+b; } return c;");
+        code.parse();
+        assertEquals("return 4;", code.print());
+    }
+
+    @Test
+    public void testVarDist() {
+        CodeGen code = new CodeGen("int x0=1; int y0=2; int x1=3; int y1=4; return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1); ");
+        code.parse();
+        assertEquals("return 8;", code.print());
+    }
+
+    @Test
+    public void testSelfAssign() {
+        try {
+            new CodeGen("int a=a; return a;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'a'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testRedeclareVar() {
+        try {
+            new CodeGen("int a=1; int b=2; int c=0; int b=3; c=a+b;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Redefining name 'b'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBad1() {
+        try {
+            new CodeGen("int a=1; int b=2; int !c=0; { int b=3; c=a+b;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Syntax error, expected }: ",e.getMessage());
+        }
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter04Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter04Test.java
new file mode 100644
index 00000000..ce808084
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter04Test.java
@@ -0,0 +1,159 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+import org.junit.Ignore;
+
+import static org.junit.Assert.*;
+
+public class Chapter04Test {
+
+    @Test
+    public void testPeephole() {
+        CodeGen code = new CodeGen("return 1+arg+2; ");
+        code.parse();
+        assertEquals("return (arg+3);", code.print());
+    }
+
+    @Test
+    public void testPeephole2() {
+        CodeGen code = new CodeGen("return (1+arg)+2;");
+        code.parse();
+        assertEquals("return (arg+3);", code.print());
+    }
+
+    @Test
+    public void testAdd0() {
+        CodeGen code = new CodeGen("return 0+arg;");
+        code.parse();
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void testAddAddMul() {
+        CodeGen code = new CodeGen("return arg+0+arg;");
+        code.parse();
+        assertEquals("return (arg<<1);", code.print());
+    }
+
+    @Test
+    public void testPeephole3() {
+        CodeGen code = new CodeGen("return 1+arg+2+arg+3; ");
+        code.parse();
+        assertEquals("return ((arg<<1)+6);", code.print());
+    }
+
+    @Test
+    public void testMul1() {
+        CodeGen code = new CodeGen("return 1*arg;");
+        code.parse();
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void testSub0() {
+        CodeGen code = new CodeGen("return arg-0;");
+        code.parse();
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void test0Sub() {
+        CodeGen code = new CodeGen("return 0-arg;");
+        code.parse();
+        assertEquals("return (-arg);", code.print());
+    }
+
+    @Test
+    public void testSubNeg() {
+        CodeGen code = new CodeGen("return 3--arg;");
+        code.parse();
+        assertEquals("return (arg+3);", code.print());
+    }
+
+    @Test
+    public void testNegSub() {
+        CodeGen code = new CodeGen("return -arg-3;");
+        code.parse();
+        assertEquals("return (-(arg+3));", code.print());
+    }
+
+    @Test
+    public void testVarArg() {
+        CodeGen code = new CodeGen("return arg; ");
+        code.parse();
+        assertTrue(code.ctrl() instanceof  FunNode);
+        assertTrue(code.expr() instanceof ParmNode);
+    }
+
+    // Adding functions means `main` does not constant fold the incoming arg value
+    @Ignore @Test
+    public void testConstantArg() {
+        CodeGen code = new CodeGen("return arg; ", TypeInteger.constant(2), 123L, true).parse();
+        assertEquals("return 2;", code.expr().in(1).toString());
+    }
+
+    @Test
+    public void testCompEq() {
+        CodeGen code = new CodeGen("return 3==3; ");
+        code.parse();
+        assertEquals("return 1;", code.print());
+    }
+
+    @Test
+    public void testCompEq2() {
+        CodeGen code = new CodeGen("return 3==4; ");
+        code.parse();
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testCompNEq() {
+        CodeGen code = new CodeGen("return 3!=3; ");
+        code.parse();
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testCompNEq2() {
+        CodeGen code = new CodeGen("return 3!=4; ");
+        code.parse();
+        assertEquals("return 1;", code.print());
+    }
+
+    @Test
+    public void testBug1() {
+        CodeGen code = new CodeGen("int a=arg+1; int !b=a; b=1; return a+2; ");
+        code.parse();
+        assertEquals("return (arg+3);", code.print());
+    }
+
+    @Test
+    public void testBug2() {
+        CodeGen code = new CodeGen("int !a=arg+1; a=a; return a; ");
+        code.parse();
+        assertEquals("return (arg+1);", code.print());
+    }
+
+    @Test
+    public void testBug3() {
+        try { new CodeGen("inta=1; return a;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Undefined name 'inta'",e.getMessage()); }
+    }
+
+    @Test
+    public void testBug4() {
+        CodeGen code = new CodeGen("return -arg;");
+        code.parse();
+        assertEquals("return (-arg);", code.print());
+    }
+
+    @Test
+    public void testBug5() {
+        CodeGen code = new CodeGen("return arg--2;");
+        code.parse();
+        assertEquals("return (arg--2);", code.print());
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter05Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter05Test.java
new file mode 100644
index 00000000..b234209f
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter05Test.java
@@ -0,0 +1,201 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter05Test {
+
+    @Test
+    public void testIfStmt() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+if (arg == 1)
+    a = arg+2;
+else {
+    a = arg-3;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,(arg+2),(arg-3));", code.print());
+    }
+
+    @Test
+    public void testTest() {
+        CodeGen code = new CodeGen(
+"""
+int c = 3;
+int b = 2;
+if (arg == 1) {
+    b = 3;
+    c = 4;
+}
+return c;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,4,3);", code.print());
+    }
+
+    @Test
+    public void testReturn2() {
+        CodeGen code = new CodeGen(
+"""
+if( arg==1 )
+    return 3;
+else
+    return 4;
+""");
+        code.parse();
+        assertEquals("return Phi(Region,3,4);", code.print());
+    }
+
+    @Test
+    public void testIfMergeB() {
+        CodeGen code = new CodeGen(
+"""
+int a=arg+1;
+int b=0;
+if( arg==1 )
+    b=a;
+else
+    b=a+1;
+return a+b;""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return ((arg<<1)+Phi(Region,2,3));", code.print());
+    }
+
+    @Test
+    public void testIfMerge2() {
+        CodeGen code = new CodeGen(
+"""
+int a=arg+1;
+int b=arg+2;
+if( arg==1 )
+    b=b+a;
+else
+    a=b+1;
+return a+b;""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return ((Phi(Region,(arg<<1),arg)+arg)+Phi(Region,4,5));", code.print());
+    }
+
+    @Test
+    public void testMerge3() {
+        CodeGen code = new CodeGen(
+"""
+int a=1;
+if( arg==1 )
+    if( arg==2 )
+        a=2;
+    else
+        a=3;
+else if( arg==3 )
+    a=4;
+else
+    a=5;
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,3,5,2,4);", code.print());
+    }
+
+    @Test
+    public void testMerge4() {
+        CodeGen code = new CodeGen(
+"""
+int a=0;
+int b=0;
+if( arg )
+    a=1;
+if( arg==0 )
+    b=2;
+return arg+a+b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return ((arg+Phi(Region,1,0))+Phi(Region,2,0));", code.print());
+    }
+
+    @Test
+    public void testMerge5() {
+        CodeGen code = new CodeGen(
+"""
+int a=arg==2;
+if( arg==1 )
+{
+    a=arg==3;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (arg==Phi(Region,3,2));", code.print());
+    }
+
+    @Test
+    public void testMergeSameCon() {
+        CodeGen code = new CodeGen(
+"""
+int a=arg;
+if( arg==1 )
+    a=3;
+else
+    a=3;
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+    }
+
+    @Test
+    public void testTrue() {
+      CodeGen code = new CodeGen("return true;").parse();
+      assertEquals("return 1;",code.print());
+    }
+
+    @Test
+    public void testHalfDef() {
+        try { new CodeGen("if( arg==1 ) int b=2; return b;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Cannot define a 'b' on one arm of an if",e.getMessage()); }
+    }
+
+    @Test
+    public void testHalfDef2() {
+        try { new CodeGen("if( arg==1 ) { int b=2; } else { int b=3; } return b;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Undefined name 'b'",e.getMessage()); }
+    }
+
+    @Test
+    public void testRegress1() {
+        try { new CodeGen("if(arg==2) int a=1; else int b=2; return a;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Cannot define a 'a' on one arm of an if",e.getMessage()); }
+    }
+
+
+    @Test
+    public void testBadNum() {
+        try { new CodeGen("return 1-;").parse();  fail(); }
+        catch( RuntimeException e ) { assertEquals("Syntax error, expected an identifier or expression: ;",e.getMessage()); }
+    }
+
+    @Test
+    public void testKeyword1() {
+        try { new CodeGen("int true=0; return true;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Expected an identifier, found 'true'",e.getMessage()); }
+    }
+
+    @Test
+    public void testKeyword2() {
+        try { new CodeGen("int else=arg; if(else) else=2; else else=1; return else;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Expected an identifier, found 'else'",e.getMessage()); }
+    }
+
+    @Test
+    public void testKeyword3() {
+        try { new CodeGen("int a=1; ififif(arg);a=2;return a;").parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Undefined name 'ififif'",e.getMessage()); }
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter06Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter06Test.java
new file mode 100644
index 00000000..53fcefed
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter06Test.java
@@ -0,0 +1,305 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter06Test {
+
+    @Test
+    public void testPeepholeReturn() {
+        CodeGen code = new CodeGen("""
+if( true ) return 2;
+return 1;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 2;", code.print());
+        assertTrue(code.ctrl() instanceof FunNode);
+    }
+
+    @Test
+    public void testPeepholeRotate() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+if (arg)
+    a = 2;
+return (arg < a) < 3; // Because (arg < a) is a bool/uint1/[0-1], its always less than 3
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+    }
+
+    @Test
+    public void testPeepholeCFG() {
+        CodeGen code = new CodeGen(
+"""
+int a=1;
+if( true )
+  a=2;
+else
+  a=3;
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 2;", code.print());
+        assertTrue(code.ctrl() instanceof FunNode);
+    }
+
+    @Test
+    public void testIfIf() {
+        CodeGen code = new CodeGen(
+"""
+int a=1;
+if( arg!=1 )
+    a=2;
+else
+    a=3;
+int b=4;
+if( a==2 )
+    b=42;
+else
+    b=5;
+return b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,42,5);", code.print());
+    }
+
+    @Test
+    public void testIfArgIf() {
+        CodeGen code = new CodeGen(
+"""
+int a=1;
+if( 1==1 )
+    a=2;
+else
+    a=3;
+int b=4;
+if( arg==2 )
+    b=a;
+else
+    b=5;
+return b;""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,2,5);", code.print());
+    }
+
+    @Test
+    public void testMerge3With2() {
+        CodeGen code = new CodeGen(
+"""
+arg=2;
+int a=1;
+if( arg==1 )
+    if( arg==2 )
+        a=2;
+    else
+        a=3;
+else if( arg==3 )
+    a=4;
+else
+    a=5;
+return a;
+""", TypeInteger.constant(2), 123L, true).driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 5;", code.print());
+    }
+
+    @Test
+    public void testMerge3With1() {
+        CodeGen code = new CodeGen(
+"""
+arg=1;
+int a=1;
+if( arg==1 )
+    if( arg==2 )
+        a=2;
+    else
+        a=3;
+else if( arg==3 )
+    a=4;
+else
+    a=5;
+return a;
+""", TypeInteger.constant(1), 123L, true).driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+    }
+
+    @Test
+    public void testMerge3Peephole() {
+        CodeGen code = new CodeGen(
+"""
+int a=1;
+if( arg==1 )
+    if( 1==2 )
+        a=2;
+    else
+        a=3;
+else if( arg==3 )
+    a=4;
+else
+    a=5;
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,3,5,4);", code.print());
+    }
+
+    @Test
+    public void testMerge3Peephole1() {
+        CodeGen code = new CodeGen(
+"""
+arg=1;
+int a=1;
+if( arg==1 )
+    if( 1==2 )
+        a=2;
+    else
+        a=3;
+else if( arg==3 )
+    a=4;
+else
+    a=5;
+return a;
+""", TypeInteger.constant(1), 123L, true);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+    }
+
+    @Test
+    public void testMerge3Peephole3() {
+        CodeGen code = new CodeGen(
+"""
+arg=3;
+int a=1;
+if( arg==1 )
+    if( 1==2 )
+        a=2;
+    else
+        a=3;
+else if( arg==3 )
+    a=4;
+else
+    a=5;
+return a;
+""", TypeInteger.constant(3), 123L, true);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+    }
+
+    @Test
+    public void testDemo1NonConst() {
+        CodeGen code = new CodeGen("""
+int a = 0;
+int b = 1;
+if( arg ) {
+    a = 2;
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,4,1);", code.print());
+    }
+
+
+    @Test
+    public void testDemo1True() {
+        CodeGen code = new CodeGen(
+"""
+arg=1;
+int a = 0;
+int b = 1;
+if( arg ) {
+    a = 2;
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b;
+""", TypeInteger.constant(1), 123L, true);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+    }
+
+    @Test
+    public void testDemo1False() {
+        CodeGen code = new CodeGen(
+"""
+arg=0;
+int a = 0;
+int b = 1;
+if( arg ) {
+    a = 2;
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b;
+""", TypeInteger.constant(0), 123L, true);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+    }
+
+    @Test
+    public void testDemo2NonConst() {
+        CodeGen code = new CodeGen("""
+int a = 0;
+int b = 1;
+int c = 0;
+if( arg ) {
+    a = 1;
+    if( arg==2 ) { c=2; } else { c=3; }
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b+c;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,6,1,5);", code.print());
+    }
+
+
+    @Test
+    public void testDemo2True() {
+        CodeGen code = new CodeGen(
+"""
+arg=1;
+int a = 0;
+int b = 1;
+int c = 0;
+if( arg ) {
+    a = 1;
+    if( arg==2 ) { c=2; } else { c=3; }
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b+c;
+""", TypeInteger.constant(1), 123L, true);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 6;", code.print());
+    }
+
+    @Test
+    public void testDemo2arg2() {
+        CodeGen code = new CodeGen(
+"""
+arg=2;
+int a = 0;
+int b = 1;
+int c = 0;
+if( arg ) {
+    a = 1;
+    if( arg==2 ) { c=2; } else { c=3; }
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b+c;
+""", TypeInteger.constant(2), 123L, true);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 5;", code.print());
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter07Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter07Test.java
new file mode 100644
index 00000000..8db31bc1
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter07Test.java
@@ -0,0 +1,222 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter07Test {
+
+    @Test
+    public void testExample() {
+        CodeGen code = new CodeGen(
+"""
+while(arg < 10) {
+    arg = arg + 1;
+}
+return arg;
+""");
+        code.parse();
+        assertEquals("return Phi(Loop,arg,(Phi_arg+1));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testRegression() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+if(arg){}else{
+    while(a < 10) {
+        a = a + 1;
+    }
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,1,Phi(Loop,1,(Phi_a+1)));", code.print());
+    }
+
+    @Test
+    public void testWhileNested() {
+        CodeGen code = new CodeGen(
+"""
+int sum = 0;
+int i = 0;
+while(i < arg) {
+    i = i + 1;
+    int j = 0;
+    while( j < arg ) {
+        sum = sum + j;
+        j = j + 1;
+    }
+}
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,Phi(Loop,Phi_sum,(Phi_sum+Phi(Loop,0,(Phi_j+1)))));", code.print());
+    }
+
+    @Test
+    public void testWhileScope() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    if (a == 2) a = 3;
+    else b = 4;
+}
+return b;
+""");
+        code.parse();
+        assertEquals("return Phi(Loop,2,Phi(Region,Phi_b,4));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhileNestedIfAndInc() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    if (a == 2) a = 3;
+    else b = 4;
+    b = b + 1;
+    a = a + 1;
+}
+return b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,2,(Phi(Region,Phi_b,4)+1));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+
+    @Test
+    public void testWhile() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+while(a < 10) {
+    a = a + 1;
+    a = a + 2;
+}
+return a;
+""");
+        code.parse();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhilePeep() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+while(a < 10) {
+    a = a + 1;
+    a = a + 2;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile2() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+while(arg) a = 2;
+return a;
+""");
+        code.parse();
+        assertEquals("return Phi(Loop,1,2);", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile2Peep() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+while(arg) a = 2;
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,1,2);", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile3() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        code.parse();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile3Peep() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile4() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        code.parse();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile4Peep() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter08Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter08Test.java
new file mode 100644
index 00000000..376e472b
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter08Test.java
@@ -0,0 +1,208 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter08Test {
+
+    @Test
+    public void testEx6() {
+        CodeGen code = new CodeGen(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        break;
+    if (arg == 6)
+        break;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,(Phi(Loop,arg,Add)+1),Add,Phi_arg);", code.print());
+        assertTrue(code.ctrl() instanceof RegionNode);
+        Assert.assertEquals( "5", Eval2.eval(code, 1));
+        Assert.assertEquals("10", Eval2.eval(code, 6));
+    }
+
+
+    @Test
+    public void testEx5() {
+        CodeGen code = new CodeGen(
+                """
+int a = 1;
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+    if (arg == 7)
+        continue;
+    a = a + 1;
+}
+return a;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,1,Phi(Region,Phi_a,(Phi_a+1),Phi_a));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+
+    @Test
+    public void testEx4() {
+        CodeGen code = new CodeGen(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+    if (arg == 6)
+        break;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,Phi(Loop,arg,(Phi_arg+1)),Add);", code.print());
+        assertTrue(code.ctrl() instanceof RegionNode);
+    }
+
+    @Test
+    public void testEx3() {
+        CodeGen code = new CodeGen(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 6)
+        break;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,Phi(Loop,arg,(Phi_arg+1)),Add);", code.print());
+        assertTrue(code.ctrl() instanceof RegionNode);
+    }
+
+
+    @Test
+    public void testEx2() {
+        CodeGen code = new CodeGen(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+    if (arg == 6)
+        continue;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,arg,(Phi_arg+1));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+
+    @Test
+    public void testEx1() {
+        CodeGen code = new CodeGen(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,arg,(Phi_arg+1));", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testRegress1() {
+        CodeGen code = new CodeGen(
+                """
+while( arg < 10 ) {
+    int a = arg+2;
+    if( a > 4 )
+        break;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void testRegress2() {
+        CodeGen code = new CodeGen("if(1) return 0;  else while(arg>- -arg) arg=arg+1; return 0;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testBreakOutsideLoop() {
+        try {
+            new CodeGen("""
+if(arg <= 10) {
+    break;
+    arg = arg + 1;
+}
+return arg;
+""").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("No active loop for a break or continue",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testRegress3() {
+        CodeGen code = new CodeGen("""
+while(arg < 10) {
+    break;
+}
+return arg;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void testRegress4() {
+        CodeGen code = new CodeGen("""
+int a = 1;
+while(arg < 10) {
+    a = a + 1;
+    if (arg > 2) {
+        int a = 17;
+        break;
+    }
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,Phi(Loop,1,(Phi_a+1)),Add);", code.print());
+        assertTrue(code.ctrl() instanceof RegionNode);
+    }
+
+    @Test
+    public void testRegress5() {
+        CodeGen code = new CodeGen("""
+int a = 1;
+while(1) {
+    a = a + 1;
+    if (a<10) continue;
+    break;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (Phi(Loop,1,Add)+1);", code.print());
+        assertTrue(code.ctrl() instanceof CProjNode prj && prj._idx==1 );
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter09Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter09Test.java
new file mode 100644
index 00000000..f24d96eb
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter09Test.java
@@ -0,0 +1,299 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.Ignore;
+
+import static org.junit.Assert.*;
+
+public class Chapter09Test {
+
+    @Test
+    @Ignore
+    public void testJig() {
+        CodeGen code = new CodeGen("""
+int v0=0;
+arg=0;
+while(v0) {
+        while(1) if(arg*arg*0==0) {}
+                while(0) {}
+    arg=1;
+}
+return 0;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+    }
+
+    @Test
+    public void testGVN1() {
+        CodeGen code = new CodeGen(
+                """
+int x = arg + arg;
+if(arg < 10) {
+    return arg + arg;
+}
+else {
+    x = x + 1;
+}
+return x;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,(arg<<1),(Shl+1));", code.print());
+        Assert.assertEquals( "2", Eval2.eval(code,  1));
+        Assert.assertEquals("23", Eval2.eval(code, 11));
+    }
+
+    @Test
+    public void testGVN2() {
+        CodeGen code = new CodeGen("return arg*arg-arg*arg;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        Assert.assertEquals("0", Eval2.eval(code,  1, 1));
+    }
+
+    @Test
+    public void testWorklist1() {
+        CodeGen code = new CodeGen("""
+int step = 1;
+while (arg < 10) {
+    arg = arg + step + 1;
+}
+return arg;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,arg,(Phi_arg+2));", code.print());
+        Assert.assertEquals("11", Eval2.eval(code,  1));
+    }
+
+    @Test
+    public void testWorklist2() {
+        CodeGen code = new CodeGen(
+                """
+int cond = 0;
+int one = 1;
+while (arg < 10) {
+    if (cond) one = 2;
+    arg = arg + one*3 + 1;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,arg,(Phi_arg+4));", code.print());
+        Assert.assertEquals("13", Eval2.eval(code,  1));
+    }
+
+    @Test
+    public void testWorklist3() {
+        CodeGen code = new CodeGen(
+                """
+int v1 = 0;
+int v2 = 0;
+int v3 = 0;
+int v4 = 0;
+int v5 = 0;
+int v6 = 0;
+int v7 = 0;
+int v8 = 0;
+while (arg) {
+    if (v1) v2 = 1;
+    if (v2) v3 = 1;
+    if (v3) v4 = 1;
+    if (v4) v5 = 1;
+    if (v5) v6 = 1;
+    if (v6) v7 = 1;
+    if (v7) v8 = 1;
+    arg = arg + v8 + 1;
+}
+return arg;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testRegionPeepBug() {
+        CodeGen code = new CodeGen(
+                """
+int v0=0;
+int v1=0;
+while(v1+arg) {
+    arg=0;
+    int v2=v0;
+    while(arg+1) {}
+    v0=1;
+    v1=v2;
+}
+return 0;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testWhile0() {
+        CodeGen code = new CodeGen("while(0) continue; if(0) arg=0; return arg;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void testWhile1() {
+        CodeGen code = new CodeGen("""
+if(0) while(0) {
+    int arg=arg;
+    while(0) {}
+}
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+
+    @Test
+    public void testPrecedence() {
+        CodeGen code = new CodeGen("return 3-1+2;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+    }
+
+    @Test
+    public void testSwap2() {
+        CodeGen code = new CodeGen("return 1+(1+1);");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+    }
+
+
+    @Test
+    public void testFuzz0() {
+        CodeGen code = new CodeGen("""
+int one = 1;
+int a = 0;
+int zero = 0;
+while(arg) {
+    a = -(one + a + 2);
+    arg = arg + 1;
+    one = one + zero;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(-(Phi_a+3)));", code.print());
+    }
+
+    @Test
+    public void testFuzz1() {
+        CodeGen code = new CodeGen("""
+while(1) {}
+while(arg) break;
+while(arg) arg=0;
+arg=0;
+int v0=0!=0<-0;
+return -0+0+0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Top;", code.print());
+    }
+
+
+    @Test
+    public void testFuzz2() {
+        CodeGen code = new CodeGen("return 0+-0;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testFuzz3() {
+        CodeGen code = new CodeGen("int v0=0; while(0==69) while(v0) return 0; return 0;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testFuzz4() {
+        CodeGen code = new CodeGen("""
+while(1) {
+    arg=0<=0;
+    if(1<0) while(arg==-0) arg=arg-arg;
+}
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Top;", code.print());
+    }
+
+    @Test
+    public void testFuzz5() {
+        CodeGen code = new CodeGen("""
+{
+    int v0=0;
+    while(1)
+            int v1=0--0;
+    while(v0)
+        break;
+    while(-v0) {
+        while(0+0+v0) continue;
+        break;
+    }
+    if(-0!=-0+0+v0) while(0+0+0+0)
+                break;
+}
+return 0!=0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Top;", code.print());
+    }
+
+    @Test
+    public void testFuzz6() {
+        CodeGen code = new CodeGen(
+"""
+int v0=0;
+while(0==1) while(v0)
+        v0=1+v0;
+return 0;        
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testFuzz7() {
+        CodeGen code = new CodeGen("""
+while(1) {}
+int v0=0;
+while(v0)
+    {}
+int v1=0;
+while(1)
+        v1=1;
+return v1+v0;
+                                   """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Top;", code.print());
+    }
+
+    @Test
+    public void testFuzz8() {
+        CodeGen code = new CodeGen("while(arg) arg = arg - 1;  return arg;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testMeet() {
+        Type t1 = Type.TOP;
+        Type t2 = TypeInteger.TOP;
+        Assert.assertEquals(TypeInteger.TOP, t1.meet(t2));
+        Assert.assertEquals(TypeInteger.TOP, t2.meet(t1));
+        t1 = Type.BOTTOM;
+        t2 = TypeInteger.BOT;
+        Assert.assertEquals(Type.BOTTOM, t1.meet(t2));
+        Assert.assertEquals(Type.BOTTOM, t2.meet(t1));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter10Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter10Test.java
new file mode 100644
index 00000000..afe0b141
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter10Test.java
@@ -0,0 +1,609 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Test;
+import com.seaofnodes.simple.node.*;
+import java.util.BitSet;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter10Test {
+    @Test public void testConditionalStoreSharing() {
+        // Sharing the writes on two of three paths must not write on the third.
+        // Return the object so Load forwarding cannot hide the physical Store.
+        String src = """
+            struct S { int x; };
+            !S !a = new S;
+            a.x = 10;
+            if (arg == 1) a.x = 9;
+            else if (arg == 2) a.x = 9;
+            return a;
+            """;
+        var code = new CodeGen(src).driver(CodeGen.Phase.LocalSched);
+        for( int arg : new int[]{0,1,2,3} ) {
+            long expected = (arg==1 || arg==2) ? 9 : 10;
+            assertEquals("S{x="+expected+"}",Eval2.eval(code,arg));
+        }
+    }
+
+    @Test public void testDeadReferenceReturn() {
+        for( String body : new String[] {
+            "return new S; return 0;",
+            "if(1) return new S; else return 0;"
+        } ) {
+            String src = "struct S { int x; }; " + body;
+            var code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+            org.junit.Assert.assertTrue(body,
+                code.expr()._type instanceof com.seaofnodes.simple.type.TypeMemPtr);
+        }
+    }
+
+
+
+    // Issue #246: null-check guards start in Chapter 10; arrays arrive in Chapter 15.
+    private static final String NULLABLE_POINT_SOURCE = """
+        struct Point { int x; };
+        !Point?[] !points = new !Point?[2];
+        points[arg] = new Point { x = 42; };
+        Point? p = points[1];
+        """;
+
+    @Test
+    public void testNullGuards() {
+        for( String body : new String[] {
+            "if (p != null) return p.x; return -1;",
+            "if (null != p) return p.x; return -1;",
+            "if (!!!!p) return p.x; return -1;",
+            "if (!!!p) return -1; return p.x;",
+            "int b = !!p; if (b) return p.x + b - 1; return -1;",
+            "if (!(p == null || arg == 0)) return p.x; return -1;"
+        } ) {
+            CodeGen code = new CodeGen(NULLABLE_POINT_SOURCE+body).driver(CodeGen.Phase.TypeCheck);
+            assertEquals(body,"-1",Eval2.eval(code,0));
+            assertEquals(body,"42",Eval2.eval(code,1));
+        }
+    }
+
+    @Test
+    public void testShortCircuitGuardScheduling() {
+        // The call result exists only on the RHS path, not above the merge.
+        CodeGen code = new CodeGen("""
+            val f = { int n -> (n+1)&7; };
+            int x = 0;
+            if (!!(arg && (x=f(arg)))) return x;
+            return -1;
+            """).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("-1",Eval2.eval(code,0));
+        assertEquals("2",Eval2.eval(code,1));
+        assertEquals("-1",Eval2.eval(code,7));
+        code.driver(CodeGen.Phase.LocalSched);
+    }
+
+    @Test
+    public void testNullGuardErrors() {
+        for( String body : new String[] {
+            "return p.x;",
+            "if (p == null) return p.x; return -1;",
+            "if (!!points) return p.x; return -1;",
+            "if (!!p) { int x = p.x; } return p.x;"
+        } ) {
+            try {
+                new CodeGen(NULLABLE_POINT_SOURCE+body).driver(CodeGen.Phase.TypeCheck);
+                fail(body);
+            } catch( RuntimeException e ) {
+                // Known null is rejected during parsing in these chapters.
+                String expected = body.startsWith("if (p == null)")
+                    ? "Accessing unknown field 'x' from 'null'" : "Might be null accessing 'x'";
+                assertEquals(body,expected,e.getMessage());
+            }
+        }
+    }
+
+    @Test
+    public void testFuzzer() {
+        CodeGen code = new CodeGen(
+"""
+int a = arg/3;
+int b = arg*5;
+int x = arg*7;
+int y = arg/11;
+int p; int g; int h;
+if( (arg/13)==0 ) {
+    p = x + y;
+    g = x;
+    h = y;
+} else {
+    p = a + b;
+    g = a;
+    h = b;
+}
+int r = g+h;
+return p-r;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testStruct() {
+        CodeGen code = new CodeGen("""
+struct Bar {
+    int a;
+    int b;
+};
+struct Foo {
+    int x;
+};
+Foo? foo = null;
+!Bar !bar = new Bar;
+bar.a = 1;
+bar.a = 2;
+return bar.a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 2;", code.print());
+    }
+
+    @Test
+    public void testExample() {
+        CodeGen code = new CodeGen("""
+struct Vector2D { int x; int y; };
+!Vector2D !v = new Vector2D;
+v.x = 1;
+if (arg)
+    v.y = 2;
+else
+    v.y = 3;
+return v;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Vector2D;", code.print());
+    }
+
+    @Test
+    public void testBug() {
+        CodeGen code = new CodeGen("""
+struct s0 {
+    int v0;
+};
+s0? v1=null;
+int v3=v1.zAicm;
+""");
+        try { code.parse();  fail(); }
+        catch( Exception e ) {  assertEquals("Accessing unknown field 'zAicm' from 'null'",e.getMessage());  }
+    }
+
+    @Test
+    public void testBug2() {
+        CodeGen code = new CodeGen("""
+struct s0 { int v0; };
+arg=0+new s0.0;
+""");
+        try { code.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Expected an identifier, found 'null'",e.getMessage()); }
+    }
+
+    @Test
+    public void testLoop() {
+        CodeGen code = new CodeGen("""
+struct Bar { int a; };
+!Bar !bar = new Bar;
+while (arg) {
+    bar.a = bar.a + 2;
+    arg = arg + 1;
+}
+return bar.a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi_a+2));", code.print());
+    }
+
+    @Test
+    public void testIf() {
+        CodeGen code = new CodeGen("""
+struct Bar { int a; };
+!Bar !bar = new Bar;
+if (arg) bar = null;
+bar.a = 1;
+return bar.a;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Type null is not of declared type *Bar",e.getMessage()); }
+    }
+
+    @Test
+    public void testIf2() {
+        CodeGen code = new CodeGen("""
+struct Bar { int a; };
+!Bar? !bar = null;
+if (arg) bar = new Bar;
+bar.a = 1;
+return bar.a;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Might be null accessing 'a'",e.getMessage()); }
+    }
+
+    @Test
+    public void testIf3() {
+        CodeGen code = new CodeGen("""
+struct Bar { int a; };
+!Bar !bar = null;
+if (arg) bar = null;
+bar.a = 1;
+return bar.a;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Type null is not of declared type *Bar", e.getMessage()); }
+    }
+
+    @Test
+    public void testIfOrNull() {
+        CodeGen code = new CodeGen("""
+struct Bar { int a; };
+!Bar? !bar = new Bar;
+if (arg) bar = null;
+if( bar ) bar.a = 1;
+return bar;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,null,Bar);", code.print());
+    }
+
+    @Test
+    public void testIfOrNull2() {
+        CodeGen code = new CodeGen(
+"""
+struct Bar { int a; };
+!Bar? !bar = new Bar;
+if (arg) bar = null;
+int rez = 3;
+if( !bar ) rez=4;
+else bar.a = 1;
+return rez;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,4,3);", code.print());
+    }
+
+    @Test
+    public void testWhileWithNullInside() {
+        CodeGen code = new CodeGen("""
+struct s0 {int v0;};
+!s0? !v0 = new s0;
+int ret = 0;
+while(arg) {
+    ret = v0.v0;
+    v0 = null;
+    arg = arg - 1;
+}
+return ret;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) {
+            assertEquals("Might be null accessing 'v0'", e.getMessage()); }
+    }
+
+    @Test
+    public void testRedeclareStruct() {
+        CodeGen code = new CodeGen("""
+struct s0 {
+    int v0;
+};
+s0? v1=new s0;
+!s0? !v1;
+v1=new s0;
+""");
+        try { code.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Redefining name 'v1'", e.getMessage()); }
+    }
+
+    @Test
+    public void testIter() {
+        // Build and use an iterator
+        CodeGen code = new CodeGen(
+"""
+struct Iter {
+    int x;
+    int len;
+};
+!Iter !i = new Iter;
+i.len = arg;
+int sum=0;
+while( i.x < i.len ) {
+    sum = sum + i.x;
+    i.x = i.x + 1;
+}
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi(Loop,0,(Phi_x+1))+Phi_sum));", code.print());
+    }
+
+
+    @Test
+    public void test1() {
+        CodeGen code = new CodeGen("""
+struct s0 {int v0;};
+!s0 !ret = new s0;
+while(arg) {
+    !s0 !v0 = new s0;
+    v0.v0 = arg;
+    arg = arg-1;
+    if (arg==5) ret=v0;
+
+}
+return ret;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,s0,Phi(Region,s0,Phi_ret));", code.print());
+    }
+
+    @Test
+    public void test2() {
+        CodeGen code = new CodeGen("""
+struct s0 {int v0;};
+!s0 !ret = new s0;
+!s0 !v0 = new s0;
+while(arg) {
+    v0.v0 = arg;
+    arg = arg-1;
+    if (arg==5) ret=v0;
+
+}
+return ret;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,s0,Phi(Region,s0,Phi_ret));", code.print());
+    }
+
+
+    @Test
+    public void test3() {
+        CodeGen code = new CodeGen("""
+struct s0 {int v0;};
+!s0 !ret = new s0;
+while(arg < 10) {
+    !s0 !v0 = new s0;
+    if (arg == 5) ret=v0;
+    arg = arg + 1;
+}
+return ret;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,s0,Phi(Region,s0,Phi_ret));", code.print());
+    }
+
+    @Test
+    public void testBug3() {
+        CodeGen code = new CodeGen("""
+struct s0 { int f0; };
+return new s0;
+int v0=null.f0;
+""");
+        try { code.parse();  fail(); }
+        catch( Exception e ) {  assertEquals("Syntax error, expected ;: .",e.getMessage());  }
+    }
+
+    @Test
+    public void testBug4() {
+        CodeGen code = new CodeGen("""
+if(0) {
+    while(0) if(arg) continue;
+    int v0=0;
+    while(1) {
+        int v2=-arg;
+        v0=v2;
+    }
+}
+return 0;
+   """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testBug5() {
+        CodeGen code = new CodeGen("""
+struct s0 {
+    int f0;
+};
+if(0) return 0;
+else return new s0;
+if(new s0.f0) return 0;
+    """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return s0;", code.print());
+    }
+
+    @Test
+    public void testBug6MissedWorklist() {
+        CodeGen code = new CodeGen("""
+while(0) {}
+int v4=0;
+while(0<arg) {
+    v4=v4+1;
+    while(1) v4=-v4;
+    while(0) arg=-1;
+}
+return 0;
+    """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+    }
+
+    @Test
+    public void testBug7() {
+        CodeGen code = new CodeGen("""
+struct s0 {  int f0; };
+s0 v0 = new s0;
+while(v0.f0) {}
+s0 v1 = v0;
+return v1;
+    """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (const)s0;", code.print());
+    }
+
+
+    @Test
+    public void testBug8() {
+        CodeGen code = new CodeGen("""
+int v2=0;
+while(0)
+while(0) {}
+{
+    {
+        {
+            int v36=0;
+            {
+                while(0) {
+                    {
+                        while(-v2) {
+                            {
+                                while(v36) {
+                                                while(v2) return 0;
+                                                break;
+                                }                            }
+                            if(-v2) break;
+                        }
+                    }
+                }
+            }
+        }    }
+}
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testBug9() {
+        CodeGen code = new CodeGen("""
+int v0=arg==0;
+while(v0) continue;
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test public void testReadBeforeStores() {
+        var code = new CodeGen("""
+            struct S { int x; int y; };
+            !S !a = new S; !S !b = new S;
+            a.x = 11; b.x = 22;
+            !S !p = a; if (arg) p = b;
+            int before = p.x;
+            a.y = 55; b.y = 66;
+            a.x = 33; b.x = 44;
+            return before*100 + p.x;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        StopNode stop = code._stop;
+        assertEquals("1133",Eval2.eval(code,0));
+        assertEquals("2244",Eval2.eval(code,1));
+    }
+
+    static final String NESTED_MEMORY = """
+            struct S { int x; int y; int z; };
+            !S !s = new S;
+            s.x = 5; s.y = 7; s.z = 11;
+            while (arg > 0) {
+                s.x = s.x + 1;
+                int j = 3;
+                while (j > 0) {
+                    j = j - 1;
+                    if (j == 1) continue;
+                    s.y = s.y + arg;
+                    if (arg == 2) break;
+                    s.z = s.z + 1;
+                }
+                arg = arg - 1;
+            }
+            return s;
+            """;
+
+    @Test public void testMemoryAcrossNestedLoops() {
+        var code = new CodeGen(NESTED_MEMORY).driver(CodeGen.Phase.FinalizeIR);
+        StopNode stop = code._stop;
+        for (int arg=0; arg<7; arg++) {
+            assertEquals("S{x="+(5L+arg)+",y="+(7L+arg*(arg+1)-(arg>=2 ? 2 : 0))+
+                         ",z="+(11L+2*arg-(arg>=2 ? 2 : 0))+"}",Eval2.eval(code,arg));
+        }
+    }
+
+    @Test public void testMemoryAtEarlyReturns() {
+        var code = new CodeGen("""
+            struct S { int x; int y; int z; };
+            !S !s = new S;
+            s.x = 3; s.y = 5; s.z = 7;
+            if (arg) { s.x = 11; s.z = 13; return s; }
+            s.y = 17;
+            return s;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        StopNode stop = code._stop;
+        for (int arg=0; arg<2; arg++) {
+            assertEquals(arg==0 ? "S{x=3,y=17,z=7}" : "S{x=11,y=5,z=13}",Eval2.eval(code,arg));
+        }
+    }
+
+    @Test public void testKeepLoadsAtMerge() {
+        var code = new CodeGen("""
+            struct S { int x; };
+            !S !a = new S; !S !b = new S;
+            a.x = arg; b.x = arg+1;
+            !S !p = a; !S !q = b;
+            if (arg<0) { p=b; q=a; }
+            int v;
+            if (arg>1) v=p.x; else v=q.x;
+            return v;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        StopNode stop = code._stop;
+        // The one-step safety check stops at the memory aggregate.
+        assertEquals(2,countMemoryNodes(stop,LoadNode.class,new BitSet()));
+        assertEquals("-1",Eval2.eval(code,-1));
+        assertEquals("1",Eval2.eval(code,0));
+        assertEquals("3",Eval2.eval(code,3));
+    }
+
+    @Test public void testKeepBranchStores() {
+        var code = new CodeGen("""
+            struct S { int x; };
+            !S !s = new S;
+            if (arg) s.x=arg+1; else s.x=arg+2;
+            return s;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        StopNode stop = code._stop;
+        // Keep each Store on its own branch.
+        assertEquals(2,countMemoryNodes(stop,StoreNode.class,new BitSet()));
+        assertEquals("S{x=2}",Eval2.eval(code,0));
+        assertEquals("S{x=4}",Eval2.eval(code,3));
+    }
+
+    @Test public void testKeepReadsBeforeWrites() {
+        var code = new CodeGen("""
+            struct S { int x; int y; };
+            !S !a = new S; !S !b = new S;
+            a.x=arg; b.x=arg+1;
+            !S !p=a; !S !q=b;
+            if (arg<0) { p=b; q=a; }
+            int v;
+            if (arg>1) { v=p.x; p.x=41; p.y=5; }
+            else       { v=q.x; q.x=42; }
+            return v;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        StopNode stop = code._stop;
+        assertEquals(2,countMemoryNodes(stop,LoadNode.class,new BitSet()));
+        assertEquals("-1",Eval2.eval(code,-1));
+        assertEquals("1",Eval2.eval(code,0));
+        assertEquals("3",Eval2.eval(code,3));
+    }
+
+    private static int countMemoryNodes(Node n, Class<?> kind, BitSet seen) {
+        if (n==null || seen.get(n._nid)) return 0;
+        seen.set(n._nid);
+        int cnt=kind.isInstance(n) ? 1 : 0;
+        for (Node def : n._inputs) cnt+=countMemoryNodes(def,kind,seen);
+        return cnt;
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter11Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter11Test.java
new file mode 100644
index 00000000..7c5e05f8
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter11Test.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.*;
+import com.seaofnodes.simple.node.*;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter11Test {
+    @Test public void testIndependentField() {
+        var code = new CodeGen("""
+            struct S { int x; int y; };
+            !S !s = new S;
+            s.x = 42;
+            while (arg > 0) { s.y = s.y + arg; arg = arg - 1; }
+            return s.x;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        var stop = code._stop;
+        assertEquals("return 42;",stop.toString());
+        assertEquals("42",Eval2.eval(code,5));
+        assertNull(stop.walk(n -> n instanceof LoadNode ? n : null));
+    }
+
+    @Test public void testParallelMemoryPhis() {
+        var code = new CodeGen("""
+            struct S { int x; int y; int z; };
+            !S !a = new S; !S !b = new S;
+            !S !p = a; if (arg) p = b;
+            while (arg > 0) {
+                a.x = p.x + arg;
+                a.y = p.y + 2;
+                a.z = p.z + 3;
+                arg = arg - 1;
+            }
+            return a;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        var stop = code._stop;
+        int[] phis = {0};
+        stop.walk(n -> {
+            // Store sinking can replace field memory Phis with value Phis.
+            if (n instanceof PhiNode) phis[0]++;
+            if (n instanceof MemMergeNode m && m.in(1) instanceof BulkMemPhiNode b)
+                for(int a=b._aliases.nextSetBit(0); a>=0; a=b._aliases.nextSetBit(a+1))
+                    assertTrue(a<m.nIns() && m.in(a)!=null);
+            assertFalse(n instanceof PhiNode && n.isMem() &&
+                !(n instanceof MemPhiNode) && !(n instanceof BulkMemPhiNode) && !(n instanceof ParmNode));
+            return null;
+        });
+        assertTrue(phis[0]>=4); // Three fields and the loop counter.
+        assertEquals("S{x=1,y=2,z=3}",Eval2.eval(code,4));
+    }
+
+    @Test public void testLateSliceWorklist() {
+        // Seed 97 exposed a store selecting a bulk predecessor without queuing
+        // it. Keep both the worklist assertion and the final heap check.
+        for (int seed : new int[]{0,97,123,456}) {
+            var code = new CodeGen(Chapter10Test.NESTED_MEMORY,com.seaofnodes.simple.type.TypeInteger.BOT,seed,false).parse();
+            code.iter().opto().iterPostOpto().finalizeIR();
+            assertEquals("S{x=9,y=25,z=17}",Eval2.eval(code,4));
+        }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter12Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter12Test.java
new file mode 100644
index 00000000..2ef209c5
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter12Test.java
@@ -0,0 +1,283 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter12Test {
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 3.14;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3.14;", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testLinkedList0() {
+        CodeGen code = new CodeGen(
+"""
+struct LLI { !LLI? !next; int i; };
+!LLI? !head = null;
+while( arg ) {
+    !LLI !x = new LLI;
+    x.next = head;
+    x.i = arg;
+    head = x;
+    arg = arg-1;
+}
+return head.next.i;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Might be null accessing 'next'",e.getMessage()); }
+    }
+
+    @Test
+    public void testLinkedList1() {
+        CodeGen code = new CodeGen(
+"""
+struct LLI { !LLI? !next; int q; };
+!LLI? !head = null;
+while( arg ) {
+    !LLI !x = new LLI;
+    x.next = head;
+    x.q = arg;
+    head = x;
+    arg = arg-1;
+}
+if( !head ) return 0;
+LLI? next = head.next;
+if( next==null ) return 1;
+return next.q;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return Phi(Region,0,1,.q);", code.print());
+        assertEquals("2", Eval2.eval(code,  3));
+    }
+
+    @Test
+    public void testCoRecur() {
+        CodeGen code = new CodeGen(
+"""
+struct int0 { int i; !flt0? !f; };
+struct flt0 { flt f; !int0? !i; };
+!int0 !i0 = new int0;
+i0.i = 17;
+!flt0 !f0 = new flt0;
+f0.f = 3.14;
+i0.f = f0;
+f0.i = i0;
+return f0.i.f.i.i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 17;", code.print());
+    }
+
+    @Test
+    public void testNullRef0() {
+        CodeGen code = new CodeGen(
+"""
+struct N { !N? !next; int i; };
+N n = new N;
+return n.next;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return null;", code.print());
+    }
+
+    @Test
+    public void testNullRef1() {
+        CodeGen code = new CodeGen(
+"""
+struct M { int m; };
+struct N { !M !next; int i; };
+N n = new N { next = new M; };
+return n.next;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (const)M;", code.print());
+    }
+
+    @Test
+    public void testNullRef2() {
+        CodeGen code = new CodeGen(
+"""
+struct M { int m; };
+struct N { !M !next; int i; };
+N n = new N { next = null; };
+return n.next;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Type null is not of declared type *M",e.getMessage()); }
+    }
+
+    @Test
+    public void testNullRef3() {
+        CodeGen code = new CodeGen(
+"""
+struct N { !N? !next; int i; };
+!N !n = new N;
+n.i = 3.14;
+return n.i;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("3",Eval2.eval(code,0));
+    }
+
+    @Test
+    public void testNullRef4() {
+        CodeGen code = new CodeGen("return -null-5/null-5;");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot '//' null",e.getMessage()); }
+    }
+
+    @Test public void testNullRef5() {
+        CodeGen code = new CodeGen("return null+42;");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot '+' null",e.getMessage()); }
+    }
+
+    @Test
+    public void testEmpty() {
+        CodeGen code = new CodeGen(
+"""
+struct S{};
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testForwardRef0() {
+        CodeGen code = new CodeGen(
+"""
+struct S1 { !S2? !s; };
+return new S2;
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Unknown struct type 'S2'",e.getMessage()); }
+    }
+
+    @Test
+    public void testForwardRef1() {
+        CodeGen code = new CodeGen(
+"""
+struct S1 { !S2? !s; };
+struct S2 { int x; };
+return new S1.s=new S2;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return S2;", code.print());
+    }
+
+    @Test
+    public void testcheckNull() {
+        CodeGen code = new CodeGen(
+"""
+struct I { int i; };
+struct P { !I? !pi; };
+!P !p1 = new P;
+!P !p2 = new P;
+p2.pi = new I;
+p2.pi.i = 2;
+if (arg) p1 = new P;
+return p1.pi.i + 1;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck);  fail(); }
+        catch( Exception e ) {  assertEquals("Might be null accessing 'i'",e.getMessage());  }
+    }
+
+    @Test
+    public void testCoRecur2() {
+        CodeGen code = new CodeGen(
+"""
+struct A { !B? !f0; !C? !f1; };  !A !a = new A;
+struct B { !C? !f0; !A? !f1; };  !B !b = new B;
+struct C { !A? !f0; !B? !f1; };  !C !c = new C;
+
+a.f0=b;  a.f1=c;
+b.f0=c;  b.f1=a;
+c.f0=a;  c.f1=b;
+
+return a.f0.f1.f0.f1.f0;
+
+""");
+        code.driver(CodeGen.Phase.LocalSched);
+        assertEquals("return B;", code._stop.toString());
+        assertEquals("B{f0=C},f1=A{f0=$cyclic,f1=$cyclic}}", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testCoRecur3() {
+        CodeGen code = new CodeGen(
+"""
+struct A { !L? !a; !T? !b; !F? !c; };  !A !a = new A;
+struct B { !M? !a; !U? !b; !G? !c; };  !B !b = new B;
+struct C { !N? !a; !V? !b; !H? !c; };  !C !c = new C;
+struct D { !O? !a; !W? !b; !I? !c; };  !D !d = new D;
+struct E { !P? !a; !X? !b; !J? !c; };  !E !e = new E;
+struct F { !Q? !a; !Y? !b; !K? !c; };  !F !f = new F;
+struct G { !R? !a; !Z? !b; !L? !c; };  !G !g = new G;
+struct H { !S? !a; !A? !b; !M? !c; };  !H !h = new H;
+struct I { !T? !a; !B? !b; !N? !c; };  !I !i = new I;
+struct J { !U? !a; !C? !b; !O? !c; };  !J !j = new J;
+struct K { !V? !a; !D? !b; !P? !c; };  !K !k = new K;
+struct L { !W? !a; !E? !b; !Q? !c; };  !L !l = new L;
+struct M { !X? !a; !F? !b; !R? !c; };  !M !m = new M;
+struct N { !Y? !a; !G? !b; !S? !c; };  !N !n = new N;
+struct O { !Z? !a; !H? !b; !T? !c; };  !O !o = new O;
+struct P { !A? !a; !I? !b; !U? !c; };  !P !p = new P;
+struct Q { !B? !a; !J? !b; !V? !c; };  !Q !q = new Q;
+struct R { !C? !a; !K? !b; !W? !c; };  !R !r = new R;
+struct S { !D? !a; !L? !b; !X? !c; };  !S !s = new S;
+struct T { !E? !a; !M? !b; !Y? !c; };  !T !t = new T;
+struct U { !F? !a; !N? !b; !Z? !c; };  !U !u = new U;
+struct V { !G? !a; !O? !b; !A? !c; };  !V !v = new V;
+struct W { !H? !a; !P? !b; !B? !c; };  !W !w = new W;
+struct X { !I? !a; !Q? !b; !C? !c; };  !X !x = new X;
+struct Y { !J? !a; !R? !b; !D? !c; };  !Y !y = new Y;
+struct Z { !K? !a; !S? !b; !E? !c; };  !Z !z = new Z;
+
+a.a=l;  a.b=t; a.c=f;
+b.a=m;  b.b=u; b.c=g;
+c.a=n;  c.b=v; c.c=h;
+d.a=o;  d.b=w; d.c=i;
+e.a=p;  e.b=x; e.c=j;
+f.a=q;  f.b=y; f.c=k;
+g.a=r;  g.b=z; g.c=l;
+h.a=s;  h.b=a; h.c=m;
+i.a=t;  i.b=b; i.c=n;
+j.a=u;  j.b=c; j.c=o;
+k.a=v;  k.b=d; k.c=p;
+l.a=w;  l.b=e; l.c=q;
+m.a=x;  m.b=f; m.c=r;
+n.a=y;  n.b=g; n.c=s;
+o.a=z;  o.b=h; o.c=t;
+p.a=a;  p.b=i; p.c=u;
+q.a=b;  q.b=j; q.c=v;
+r.a=c;  r.b=k; r.c=w;
+s.a=d;  s.b=l; s.c=x;
+t.a=e;  t.b=m; t.c=y;
+u.a=f;  u.b=n; u.c=z;
+v.a=g;  v.b=o; v.c=a;
+w.a=h;  w.b=p; w.c=b;
+x.a=i;  x.b=q; x.c=c;
+y.a=j;  y.b=r; y.c=d;
+z.a=k;  z.b=s; z.c=e;
+
+return a.b.c.a.b.c.a.b.c.a.b.c.a.b.c.a.b.c;
+
+""");
+        code.driver(CodeGen.Phase.LocalSched);
+        assertEquals("return R;", code._stop.toString());
+        assertEquals("R{a=C{a=N},b=V},c=H}},b=K{a=$cyclic,b=D{a=O},b=W},c=I}},c=P}},c=$cyclic}", Eval2.eval(code,  0));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter13Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter13Test.java
new file mode 100644
index 00000000..3301fa5e
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter13Test.java
@@ -0,0 +1,266 @@
+package com.seaofnodes.simple;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.print.IRPrinter;
+
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+public class Chapter13Test {
+
+    @Test
+    public void testPrimes() {
+        CodeGen code = new CodeGen(
+"""
+if( arg < 2 ) return 0;
+int primeCount = 1;
+int prime = 3;
+while( prime <= arg ) {
+    int isPrime = 1;
+    // Check for even case, so the next loop need only check odds
+    if( (prime/2)*2 == prime )
+        continue;
+    // Check odds up to sqrt of prime
+    int j = 3;
+    while( j*j <= prime ) {
+        if( (prime/j)*j == prime ) {
+            isPrime = 0;
+            break;
+        }
+        j = j + 2;
+    }
+    if( isPrime )
+        primeCount = primeCount + 1;
+    prime = prime + 2;
+}
+return primeCount;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,0,Phi(Loop,1,Phi(Region,Phi_primeCount,Phi_primeCount,(Phi_primeCount+1))));", code.print());
+        assertEquals("0", Eval2.eval(code,  1)); // No primes 1 or below
+        assertEquals("1", Eval2.eval(code,  2)); // 2
+        assertEquals("2", Eval2.eval(code,  3)); // 2, 3
+        assertEquals("2", Eval2.eval(code,  4)); // 2, 3
+        assertEquals("3", Eval2.eval(code,  5)); // 2, 3, 5
+        assertEquals("4", Eval2.eval(code, 10)); // 2, 3, 5, 7
+    }
+
+    @Test
+    public void testAntiDeps1() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v=new S;
+v.f = 2;
+int i=new S.f;
+i=v.f;
+if (arg) v.f=1;
+return i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 2;", code.print());
+        assertEquals("2", Eval2.eval(code, 0));
+        assertEquals("2", Eval2.eval(code, 1));
+    }
+
+    @Test
+    public void testAntiDeps2() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+v.f = arg;
+!S !t = new S;
+int i = 0;
+if (arg) {
+    if (arg+1) v = t;
+    i = v.f;
+} else {
+    v.f = 2;
+}
+return i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,.f,0);", code.print());
+    }
+
+    @Test
+    public void testAntiDeps3() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v0 = new S;
+!S? !v1;
+if (arg) v1 = new S;
+if (v1) {
+    v0.f = v1.f;
+} else {
+    v0.f = 2;
+}
+return v0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return S;", code.print());
+    }
+
+
+    @Test
+    public void testAntiDeps4() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+v.f = arg;
+S t = new S;
+int i = v.f;
+if (arg+1) arg= 0;
+while (arg) v.f = 2;
+return i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return arg;", code.print());
+    }
+
+    @Test
+    public void testAntiDeps5() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+while(1) {
+    while(arg+1) { arg=arg-1; }
+    if (arg) break;
+    v.f = 2;
+}
+return v;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return S;", code.print());
+    }
+
+    @Test
+    public void testAntiDeps6() {
+        CodeGen code = new CodeGen(
+"""
+struct s { int v; };
+!s !ptr=new s;
+while( -arg )
+  ptr = new s;
+while(1)
+  arg = arg+ptr.v;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Top;", code.print());
+    }
+
+    @Test
+    public void testAntiDeps7() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+S t = new S;
+int i = v.f;
+while (arg) {
+    v.f = arg;
+    arg = arg-1;
+}
+return i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testAntiDeps8() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+S t = new S;
+while(arg) {
+    arg=arg-1;
+    int f = v.f;
+    v.f = 2;
+    if (arg) arg = f;
+    else v.f = 3;
+}
+return arg;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testAntiDeps9() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+S t = new S;
+if (arg) {
+    v.f=2;
+    int i=t.f;
+    v.f=i;
+}
+return v;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return S;", code.print());
+    }
+
+    @Test
+    public void testExample2() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int f; };
+!S !v = new S;
+int i = arg;
+while (arg > 0) {
+    int j = i/3;
+    if (arg == 5)
+        v.f = j;
+    arg = arg - 1;
+}
+return v;
+                """);
+        code.driver(CodeGen.Phase.FinalizeIR);
+        //assertEquals("return new S;", code.print());
+    }
+
+    @Test
+    public void testScheduleUse() {
+        CodeGen code = new CodeGen(
+"""
+int v0=0;
+while(0>=0) {
+    u1 v1=0;
+    v1=v0;
+    if(v1*0)
+        v0=-v1;
+}
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Top;", code.print());
+    }
+
+    @Test
+    public void testLoopCarriedDep() {
+        CodeGen code = new CodeGen(
+"""
+u32 v0=0;
+{
+    int v1=0;
+    while(v1) {
+        v1=1>>>v0!=0;
+        v0=v1/0;
+    }
+    return v1;
+}
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter14FloatTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter14FloatTest.java
new file mode 100644
index 00000000..b0cf0a91
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter14FloatTest.java
@@ -0,0 +1,103 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter14FloatTest {
+    @Test public void testNumericAssignments() {
+        String[][] tests = {
+            {"int rounded=17.3/2.5; return rounded;", "6", "6"},
+            {"int rounded=arg/2.5; return rounded;", "6", "-6"},
+            {"int rounded=0; rounded=arg/2.5; return rounded;", "6", "-6"},
+            {"i8 rounded=arg*16.0; return rounded;", "16", "-16"},
+            {"int rounded=1e100; return rounded;", "9223372036854775807", "9223372036854775807"},
+            {"int rounded=-1e100; return rounded;", "-9223372036854775808", "-9223372036854775808"},
+            {"int rounded=1e300*1e300-1e300*1e300; return rounded;", "0", "0"},
+            {"f32 rounded=arg+16777216.0; return rounded;", "1.6777232E7", "1.6777199E7"}
+        };
+        for( String[] test : tests ) {
+            var code = new CodeGen(test[0]).driver(CodeGen.Phase.TypeCheck);
+            assertEquals(test[0],test[1],Eval2.eval(code,17));
+            assertEquals(test[0],test[2],Eval2.eval(code,-17));
+        }
+    }
+
+
+    @Test public void testSubZeroFloat() {
+        var code = new CodeGen("flt x = arg; return 0-x;").driver(CodeGen.Phase.TypeCheck);
+        // Compare strings so +0.0 and -0.0 remain distinct.
+        assertEquals("0.0", Eval2.eval(code,0));
+        assertEquals("-1.0", Eval2.eval(code,1));
+    }
+
+    @Test public void testDeadNumericReturns() {
+        for( String[] test : new String[][] {
+            {"if(1) return 7; else return 2.5;", "7"},
+            {"if(0) return 7; else return 2.5;", "2.5"},
+            {"return 7; return 2.5;", "7"},
+            {"return 2.5; return 7;", "2.5"}
+        } ) {
+            String src = test[0];
+            var code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+            assertEquals(src,test[1],Eval2.eval(code,0));
+        }
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 3.14;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3.14;", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testFloat() {
+        CodeGen code = new CodeGen(
+"""
+return 3.14;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3.14;", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testSquareRoot() {
+        CodeGen code = new CodeGen(
+"""
+flt guess = arg;
+while( 1 ) {
+    flt next = (arg/guess + guess)/2;
+    if( next == guess ) break;
+    guess = next;
+}
+return guess;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,(flt)arg,(((ToFloat/Phi_guess)+Phi_guess)*0.5f));", code.print());
+        assertEquals("3.0", Eval2.eval(code,  9));
+        assertEquals("1.414213562373095", Eval2.eval(code,  2));
+    }
+
+    @Test
+    public void testFPOps() {
+        CodeGen code = new CodeGen(
+"""
+flt x = arg;
+return x+1==x;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return ((flt)arg==(ToFloat+1.0f));", code.print());
+        assertEquals("0", Eval2.eval(code, 1));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter14Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter14Test.java
new file mode 100644
index 00000000..b4a27c04
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter14Test.java
@@ -0,0 +1,228 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter14Test {
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 3.14;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3.14;", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testRange() {
+        CodeGen code = new CodeGen(
+"""
+int b;
+if( arg ) b=1; else b=0;
+int c = 99;
+if( b < 0 ) c = -1;
+if( b > 2 ) c =  1;
+return c;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 99;", code.print());
+        assertEquals("99", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testU8() {
+        CodeGen code = new CodeGen(
+"""
+u8 b = 123;
+b = b + 456;// Truncate
+return b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 67;", code.print());
+        assertEquals("67", Eval2.eval(code,  0));
+    }
+
+
+    @Test
+    public void testU8While() {
+        CodeGen code = new CodeGen(
+"""
+u8 b = 123;
+while( b ) b = b + 456;// Truncate
+return b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testU1() {
+        CodeGen code = new CodeGen(
+"""
+bool b = 123;
+b = b + 456;// Truncate
+u1 c = b;   // No more truncate needed
+return c;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testAnd() {
+        CodeGen code = new CodeGen(
+"""
+int b = 123;
+b = b+456 & 31;                 // Precedence
+return b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+        assertEquals("3", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testRefLoad() {
+        CodeGen code = new CodeGen(
+"""
+struct Foo { u1 b; };
+!Foo !f = new Foo;
+f.b = 123;
+return f.b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testSigned() {
+        CodeGen code = new CodeGen(
+"""
+i8 b = 255;                     // Chopped
+return b;                       // Sign extend
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return -1;", code.print());
+        assertEquals("-1", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testI8() {
+        CodeGen code = new CodeGen(
+"""
+i8 b = arg;
+b = b + 1;// Truncate
+return b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (((((arg<<56)>>56)+1)<<56)>>56);", code.print());
+        assertEquals("1", Eval2.eval(code, 0));
+        assertEquals("-128", Eval2.eval(code, 127));
+    }
+
+    @Test
+    public void testMask() {
+        CodeGen code = new CodeGen(
+"""
+u16 mask = (1<<16)-1;           // AND mask
+int c = 123456789 & mask;
+return c;                       //
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 52501;", code.print());
+        assertEquals("52501", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testOr() {
+        CodeGen code = new CodeGen(
+"""
+return (arg | 123 ^ 456) >>> 1;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (((arg|123)^456)>>>1);", code.print());
+        assertEquals("217", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testMaskFloat() {
+        CodeGen code = new CodeGen(
+"""
+flt f = arg;
+arg = f & 1;
+return arg;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot '&' flt",e.getMessage()); }
+    }
+
+    @Test
+    public void testCloneAnd() {
+        CodeGen code = new CodeGen("""
+int v0=0;
+u32 v1 = 1&(1<<arg)&(1<<arg);
+while(arg) v1=-v0;
+while(v1) break;
+return v1;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,(((1<<arg)&1)&Shl),0);", code.print());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testAndHigh() {
+        CodeGen code = new CodeGen("""
+int v0=0;
+if(0&0>>>0) {
+    while(0) {
+        u8 v1=0;
+        v0=0>>>0;
+        v1=arg;
+        while(v1+0) {}
+    }
+}
+return v0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testTypes() {
+        CodeGen code = new CodeGen(
+"""
+i8  xi8  = 123456789;  if( xi8  !=        21 ) return -8;
+i16 xi16 = 123456789;  if( xi16 !=    -13035 ) return -16;
+i32 xi32 = 123456789;  if( xi32 != 123456789 ) return -32;
+i64 xi64 = 123456789;  if( xi64 != 123456789 ) return -64;
+int xint = 123456789;  if( xint != 123456789 ) return -64;
+
+u1  ui1  = 123456789;  if( ui1  !=         1 ) return 1;
+u8  ui8  = 123456789;  if( ui8  !=        21 ) return 8;
+u16 ui16 = 123456789;  if( ui16 !=     52501 ) return 16;
+u32 ui32 = 123456789;  if( ui32 != 123456789 ) return 32;
+
+flt fflt = 3.141592653589793;  if( fflt != 3.141592653589793 ) return 3;
+f64 ff64 = 3.141592653589793;  if( ff64 != 3.141592653589793 ) return 3;
+f32 ff32 = 3.141592653589793;  if( ff32 != 3.1415927410125732) return 5;
+
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter15Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter15Test.java
new file mode 100644
index 00000000..9aaafc28
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter15Test.java
@@ -0,0 +1,417 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+import org.junit.Ignore;
+import static org.junit.Assert.*;
+
+public class Chapter15Test {
+
+    @Test public void testArrayLoadDominatingControl() {
+        String src = """
+            int[] !a=new int[arg+1]; a[arg]=7;
+            if(a#>1) {
+                if(arg==2) a[1]=9;
+                return a[1];
+            }
+            return 42;
+            """;
+        var code = new CodeGen(src).parse();
+        var stop = code._stop;
+        var main = code.link(code._main);
+        var load = stop.walk(n -> n instanceof com.seaofnodes.simple.node.LoadNode ld && ld._name.equals("[]") &&
+            ld.in(0)!=null && ld.cfg0().fun()==main ? ld : null);
+        org.junit.Assert.assertNotNull(load);
+        // The parser uses current control as a placeholder for a range check.
+        // Model an explicit check already performed before the inner diamond:
+        // both predecessors are below the a#>1 true projection.
+        var region = (com.seaofnodes.simple.node.RegionNode)load.in(0);
+        var checked = region.idom().cfg(0);
+        org.junit.Assert.assertTrue(checked instanceof com.seaofnodes.simple.node.CProjNode);
+        load.setDef(0,checked);
+        code.driver(CodeGen.Phase.TypeCheck);
+        org.junit.Assert.assertTrue("Common dominating control permits Phi splitting",load.isDead());
+        var split = stop.walk(n -> n instanceof com.seaofnodes.simple.node.LoadNode ld && ld._name.equals("[]") &&
+            ld.in(0)!=null && ld.cfg0().fun()==main ? ld : null);
+        org.junit.Assert.assertNotNull(split);
+        org.junit.Assert.assertSame("The surviving read retains the earlier check",checked,split.in(0));
+        code.driver(CodeGen.Phase.LocalSched);
+        assertEquals("42",Eval2.eval(code,0));
+        assertEquals("7",Eval2.eval(code,1));
+        assertEquals("9",Eval2.eval(code,2));
+    }
+
+
+    @Test public void testArrayLoadControl() {
+        // With arg==0, a has length 1 and a[1] must not execute. The memory
+        // merge must not pull the read above its array-length guard.
+        String src = """
+            int n=1; if(arg) n=2;
+            int[] !a=new int[n]; a[arg]=7;
+            if(arg) a[1]=9;
+            if(a#>1) return a[1];
+            return 42;
+            """;
+        var code = new CodeGen(src).parse();
+        var stop = code._stop;
+        var main = code.link(code._main);
+        var load = stop.walk(n -> n instanceof com.seaofnodes.simple.node.LoadNode ld && ld._name.equals("[]") &&
+            ld.in(0)!=null && ld.cfg0().fun()==main ? ld : null);
+        org.junit.Assert.assertNotNull(load);
+        org.junit.Assert.assertNotNull("Element loads carry their range-check control",load.in(0));
+        code.driver(CodeGen.Phase.LocalSched);
+        assertEquals("42",Eval2.eval(code,0));
+        assertEquals("9",Eval2.eval(code,1));
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 3.14;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3.14;", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testCyclic() {
+        CodeGen code = new CodeGen(
+"""
+struct C { !C? !l; };
+!C !c = new C;
+c.l = c;
+return c;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return C;", code.print());
+        assertEquals("C{l=$cyclic}", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testSafetyCheck() {
+        CodeGen code = new CodeGen(
+"""
+u8[] old = new u8[0];
+u8[] !output = new u8[1];
+int i = 0;
+while (i < old#) {
+    output[i] = old[i];
+    i = i + 1;
+}
+output[i] = 1;
+return output;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return []u8;", code.print());
+        assertEquals("\u0001", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testBasic1() {
+        CodeGen code = new CodeGen(
+"""
+int[] is = new int[2];
+return is[1];
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testBasic2() {
+        CodeGen code = new CodeGen(
+"""
+int[] is = new int[2];
+int[] is2 = new int[2];
+return is[1];
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testBasic3() {
+        CodeGen code = new CodeGen(
+"""
+int[] !a = new int[2];
+a[0] = 1;
+a[1] = 2;
+return a[0];
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testBasic4() {
+        CodeGen code = new CodeGen(
+"""
+struct A { int i; };
+!A?[] !a = new !A?[2];
+return a;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return []*A?;", code.print());
+        assertEquals("*A {i64 !i; }?[ null,null]", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testBasic5() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int x; flt y; };
+// A new S
+!S !s = new S; s.x=99; s.y = 3.14;
+
+// Double-d array of Ss.  Fill in one row.
+!S?[]?[] !iss = new !S?[]?[2];
+iss[0] = new !S?[7];
+iss[0][2] = s;
+
+// Now pull out the filled-in value, with null checks
+flt rez;
+!S?[]? is = iss[arg];
+if( !is ) rez = 1.2;
+else {
+    S? i = is[2];
+    if( !i ) rez = 2.3;
+    else rez = i.y;
+}
+return rez;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,1.2,.y,2.3);", code.print());
+        assertEquals("3.14", Eval2.eval(code, 0));
+        assertEquals("1.2", Eval2.eval(code, 1));
+    }
+
+    @Test
+    public void testBasic6() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int x; flt y; };
+// A new S
+!S !s = new S; s.x=99; s.y = 3.14;
+
+// Double-d array of Ss.  Fill in one row.
+!S?[]?[] !iss = new !S?[]?[2];
+iss[0] = new !S?[7];
+iss[0][2] = s;
+
+// Now pull out the filled-in value, with null checks
+flt rez = 1.2;
+if( iss[arg] )
+    if( iss[arg][2] )
+        rez = iss[arg][2].y;
+return rez;""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return Phi(Region,1.2,1.2,.y);", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+        try { Eval2.eval(code, 10); fail(); } // Fails AIOOBE in Eval2, no range checks
+        catch( Exception e ) { assertEquals("Index 10 out of bounds for length 2",e.getMessage()); }
+    }
+
+    @Test
+    public void testTree() {
+        CodeGen code = new CodeGen(
+"""
+// Can we define a forward-reference array?
+struct Tree { !Tree?[]? !_kids; };
+!Tree !root = new Tree;
+root._kids = new !Tree?[2]; // NO BANG SO ARRAY IS OF IMMUTABLE TREES????
+root._kids[0] = new Tree;
+return root;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Tree;", code.print());
+        assertEquals("Tree{_kids=*Tree {*[]*Tree?? !_kids; }?[ Tree{_kids=null},null]}", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testNestedStructAddMemProj() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int a; int[] !b; };
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testRollingSum() {
+        CodeGen code = new CodeGen(
+"""
+int[] !ary = new int[arg];
+// Fill [0,1,2,3,4,...]
+int i=0;
+while( i < ary# ) {
+    ary[i] = i;
+    i = i+1;
+}
+// Fill [0,1,3,6,10,...]
+i=0;
+while( i < ary# - 1 ) {
+    ary[i+1] = ary[i+1] + ary[i];
+    i = i+1;
+}
+return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (.[]+(.[]*1000));", code.print());
+        assertEquals("1006", Eval2.eval(code,  4));
+    }
+
+    @Test @Ignore
+    public void sieveOEratosthenes() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/sieve.smp"));
+        CodeGen code = new CodeGen(src+"return sieve(arg);");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return []u32;", code.print());
+        assertEquals("u32[ 2,3,5,7,11,13,17,19]",Eval2.eval(code, 20));
+    }
+
+    @Test
+    public void testNewNodeInit() {
+        CodeGen code = new CodeGen(
+"""
+struct S {int i; flt f;};
+!S !s1 = new S;
+!S !s2 = new S;
+s2.i = 3;
+s2.f = 2.0;
+if (arg) s1 = new S;
+return s1.i + s1.f;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return ((flt).i+.f);", code.print());
+        assertEquals("0.0", Eval2.eval(code,  0));
+    }
+
+
+    @Test
+    public void testBad0() {
+        CodeGen code = new CodeGen(
+"""
+return new flt;
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Cannot allocate a flt",e.getMessage()); }
+    }
+
+    @Test
+    public void testBad1() {
+        CodeGen code = new CodeGen(
+"""
+flt is = new int[2];
+return is;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Type *[]i64 is not of declared type flt",e.getMessage()); }
+    }
+
+    @Test
+    public void testBad2() {
+        CodeGen code = new CodeGen(
+"""
+int[] is = new int[3.14];
+return is[1];
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Cannot allocate an array with length 3.14",e.getMessage()); }
+    }
+
+    @Test
+    public void testBad3() {
+        CodeGen code = new CodeGen("""
+int[] is = new int[arg];
+return is[1];
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  4));
+        try { Eval2.eval(code,-1); fail(); }
+        catch( NegativeArraySizeException e ) { assertEquals("-1",e.getMessage()); }
+        // This test will not pass (i.e., failed range-check) until we have range checks.
+        // Without the range check, the load `is[1]` optimizes against the `new int[]`
+        // and assumes it loads a zero then folds away, and the Eval2 never sees an OOB load.
+        //try { Eval2.eval(code,0); fail(); }
+        //catch( ArrayIndexOutOfBoundsException e ) { assertEquals("Array index 1 out of bounds for array length 0",e.getMessage()); }
+    }
+
+    @Test
+    public void testProgress() {
+        CodeGen code = new CodeGen("""
+i8 v1=0&0;
+u8 v2=0;
+byte v4=0;
+if(0) {}
+while(v2<0) {
+    v4=0-v1;
+    break;
+}
+int v5=0&0;
+while(v5+(0&0)) {
+    int v7=0&0;
+    while(v7)
+        v4=0>>>v5;
+    while(v1)
+        return 0;
+}
+return v1;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testSharpNot() {
+        CodeGen code = new CodeGen(
+"""
+if(0>>0) {}
+while(0) {}
+u32 v7=0;
+int v8=0;
+while(0<--1>>>---(v7*0==v8)) {}
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+
+
+    @Test
+    public void testProgress2() {
+        CodeGen code = new CodeGen(
+"""
+if(1) {}
+else {
+        while(arg>>>0&0>>>0) {}
+    byte v3=0>>>0;
+                while(0) {}
+        int v7=0>>>0;
+        while(v7<0>>>0) {
+                    while(0+v7<=0) if(1) arg=-12;
+            if(arg) {
+                v3=arg+v3+0;
+                arg=0;
+            }
+        }
+}
+return 0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter16Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter16Test.java
new file mode 100644
index 00000000..d066357f
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter16Test.java
@@ -0,0 +1,172 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter16Test {
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 3.14;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3.14;", code.print());
+        assertEquals("3.14", Eval2.eval(code,  0));
+    }
+
+
+    @Test
+    public void testMulti0() {
+        CodeGen code = new CodeGen(
+"""
+int x, y;
+return x+y;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+    @Test
+    public void testMulti1() {
+        CodeGen code = new CodeGen(
+"""
+int x=2, y=x+1;
+return x+y;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 5;", code.print());
+        assertEquals("5", Eval2.eval(code,  0));
+    }
+
+
+    @Test
+    public void testConstruct0() {
+        CodeGen code = new CodeGen("""
+struct X { int x=3; };
+X z = new X;
+return z.x;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+        assertEquals("3", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testConstruct2() {
+        CodeGen code = new CodeGen("""
+struct X { int x=3; };
+X z = new X { x = 4; };
+return z.x;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+        assertEquals("4", Eval2.eval(code,  0));
+    }
+
+
+    @Test
+    public void testLinkedList1() {
+        CodeGen code = new CodeGen(
+"""
+struct LLI { !LLI? !next; int i; };
+!LLI? !head = null;
+while( arg ) {
+    head = new LLI { next=head; i=arg; };
+    arg = arg-1;
+}
+if( !head ) return 0;
+LLI? next = head.next;
+if( !next ) return 1;
+return next.i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,0,1,.i);", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+        assertEquals("1", Eval2.eval(code,  1));
+        assertEquals("2", Eval2.eval(code,  3));
+    }
+
+    @Test
+    public void testLinkedList2() {
+        CodeGen code = new CodeGen(
+"""
+struct LLI { !LLI? !next; int i; };
+!LLI? !head = null;
+while( arg ) {
+    head = new LLI {
+        next=head;
+        // Any old code in the constructor
+        int !tmp=arg;
+        while( arg > 10 ) {
+            tmp = tmp + arg;
+            arg = arg - 1;
+        }
+        i=tmp;
+    };
+    arg = arg-1;
+}
+if( !head ) return 0;
+LLI? next = head.next;
+if( !next ) return 1;
+return next.i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,0,1,.i);", code.print());
+        assertEquals("0", Eval2.eval(code,  0));
+        assertEquals("1", Eval2.eval(code,  1));
+        assertEquals("2", Eval2.eval(code, 11));
+    }
+
+    @Test
+    public void testSquare() {
+        CodeGen code = new CodeGen(
+"""
+struct Square {
+    flt !side = arg;
+    // Newtons approximation to the square root, computed in a constructor.
+    // The actual allocation will copy in this result as the initial
+    // value for 'diag'.
+    flt !diag = arg*arg/2;
+    while( 1 ) {
+        flt next = (side/diag + diag)/2;
+        if( next == diag ) break;
+        diag = next;
+    }
+};
+return new Square;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Square;", code.print());
+        assertEquals("Square{side=3.0,diag=1.7320508075688772}", Eval2.eval(code,  3));
+        assertEquals("Square{side=4.0,diag=2.0}", Eval2.eval(code, 4));
+    }
+    static final String CONSTRUCTOR_MEMORY = """
+        struct S { int x; int y; };
+        struct T { int z=arg+40; };
+        !T !t = new T;
+        !S !a = new S { x=11; y=7; };
+        !S !b = new S { x=22; y=9; };
+        !S !p=a;
+        if (arg) p=b;
+        int before=p.x;
+        !S !c = new S {
+            x=p.x+1;
+            { int i=0; while (i<2) { p.y=p.y+1; i=i+1; } }
+            y=p.y;
+        };
+        p.x=33;
+        return before*10000+c.x*100+c.y+t.z;
+        """;
+
+    @Test public void testConstructorMemory() {
+        var code = new CodeGen(CONSTRUCTOR_MEMORY).driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("111249",Eval2.eval(code,0));
+        assertEquals("222352",Eval2.eval(code,1));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter17aTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter17aTest.java
new file mode 100644
index 00000000..d03248c2
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter17aTest.java
@@ -0,0 +1,106 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter17aTest {
+
+    @Test
+    public void testFinal1() {
+        CodeGen code = new CodeGen(
+"""
+int x=2, y=3;
+if( arg ) { int x = y; x = x*x; y=x; } // Shadow final x
+return y;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,9,3);", code.print());
+        assertEquals("3", Eval2.eval(code, 0));
+        assertEquals("9", Eval2.eval(code, 1));
+    }
+
+    @Test
+    public void testConstruct1() {
+        CodeGen code = new CodeGen("""
+struct X { int ~x; };
+X z = new X { x=3; };
+return z.x;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 3;", code.print());
+        assertEquals("3", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testStructFinal0() {
+        CodeGen code = new CodeGen("""
+struct Point { int ~x, ~y; };
+Point p = new Point { x=3; y=4; };
+return p;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (const)Point;", code.print());
+        assertEquals("Point{x=3,y=4}", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testStructFinal1() {
+        CodeGen code = new CodeGen("""
+struct Point { int x=3, y=4; };
+~Point p = new Point { x=5; y=6; };
+p.x++;
+return p;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test
+    public void testStructFinal2() {
+        CodeGen code = new CodeGen("""
+struct Point { int x=3, y=4; };
+~Point p = new Point;
+p.x++;
+return p;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test
+    public void testStructFinal3() {
+        for( String fields : new String[] { "var x; var y;", "int[] !x;", "int[] !x;" } ) {
+            String src = "struct Point { "+fields+" }; Point p = new Point; p.x++; return p;";
+            try { new CodeGen(src).driver(CodeGen.Phase.FinalizeIR); fail(fields); }
+            catch( Exception e ) { assertEquals("'Point' is not fully initialized, field 'x' needs to be set in a constructor",e.getMessage()); }
+        }
+    }
+
+    @Test
+    public void testStructFinal4() {
+        CodeGen code = new CodeGen("""
+struct Point { val x=3; val y=4; };
+Point p = new Point;
+p.x++;
+return p;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test
+    public void testStructFinal5() {
+        CodeGen code = new CodeGen("""
+struct Point { var x=3; var y=4; };
+!Point !p = new Point;
+p.x++;
+return p;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Point;", code.print());
+        assertEquals("Point{x=4,y=4}", Eval2.eval(code,  0));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter17bTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter17bTest.java
new file mode 100644
index 00000000..d2fa40f3
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter17bTest.java
@@ -0,0 +1,583 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter17bTest {
+
+    @Test public void testSinkLoopStores() {
+        var code = new CodeGen("""
+            struct S { int x; };
+            !S !a = new S;
+            a.x = 10;
+            int i = 0;
+            while (i < arg) { a.x = i + 1; i++; }
+            return a;
+            """).driver(CodeGen.Phase.LocalSched);
+        int[] stores = {0};
+        code._stop.walk(n -> {
+            if( n instanceof com.seaofnodes.simple.node.StoreNode st && st._name.equals("x") ) {
+                assertEquals(0,st.cfg0().loopDepth()); // One final Store outside the loop.
+                stores[0]++;
+            }
+            return null;
+        });
+        assertEquals(1,stores[0]);
+        for( int arg : new int[]{-1,0,1,4} ) {
+            long expected = arg<=0 ? 10 : arg;
+            assertEquals("S{x="+expected+"}",Eval2.eval(code,arg));
+        }
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 1;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testInc0() {
+        CodeGen code = new CodeGen("""
+return arg++;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return arg;", code.print());
+        assertEquals("0", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testInc1() {
+        CodeGen code = new CodeGen("""
+return arg+++arg++;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return ((arg<<1)+1);", code.print());
+        assertEquals("1", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testInc2() {
+        CodeGen code = new CodeGen("""
+//   -(arg--)-(arg--)
+return -arg---arg--;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (-((arg<<1)+-1));", code.print());
+        assertEquals("1", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testInc3() {
+        CodeGen code = new CodeGen("""
+int[] !xs = new int[arg];
+xs[0]++;
+xs[1]++;
+return xs[0];
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code, 2));
+    }
+
+    @Test
+    public void testInc4() {
+        CodeGen code = new CodeGen("""
+u8[] !xs = new u8[1];
+xs[0]--;
+return xs[0];
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 255;", code.print());
+        assertEquals("255", Eval2.eval(code, 2));
+    }
+
+    @Test
+    public void testInc5() {
+        CodeGen code = new CodeGen("""
+struct S { u16 x; };
+!S !s = new S;
+s.x--;
+return s.x;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 65535;", code.print());
+        assertEquals("65535", Eval2.eval(code, 2));
+    }
+
+    @Test
+    public void testInc6() {
+        CodeGen code = new CodeGen("return --arg;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (arg+-1);", code.print());
+        assertEquals("-1", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testInc7() {
+        CodeGen code = new CodeGen("u8 x=0; return --x;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 255;", code.print());
+        assertEquals("255", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testInc8() {
+        CodeGen code = new CodeGen("int x; x+=2; return x+=3;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 5;", code.print());
+        assertEquals("5", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testInc9() {
+        CodeGen code = new CodeGen("flt x = 1.5; x++; return x;");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 2.5f;", code.print());
+        assertEquals("2.5", Eval2.eval(code, 0));
+    }
+
+    @Test public void testInt10() {
+        CodeGen code = new CodeGen("flt x = 1.5; x++; int i = x; return i;");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("2",Eval2.eval(code,0));
+    }
+
+
+    // ---------------------------------------------------------------
+    @Test public void testVar0() {
+        CodeGen code = new CodeGen("var d; return d;");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected =expression: ;",e.getMessage()); }
+    }
+
+    @Test public void testVar1() {
+        CodeGen code = new CodeGen("val d; return d;");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected =expression: ;",e.getMessage()); }
+    }
+
+    @Test public void testVar2() {
+        CodeGen code = new CodeGen("int x; x=3; x++; return x; // Ok, no initializer so x is mutable ");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+        assertEquals("4", Eval2.eval(code, 0));
+    }
+
+    @Test public void testVar3() {
+        CodeGen code = new CodeGen("int x=3; x++; return x; // Ok, primitive so x is mutable despite initializer ");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+        assertEquals("4", Eval2.eval(code, 0));
+    }
+
+    @Test public void testVar4() {
+        CodeGen code = new CodeGen("struct S{int x;}; !S? !s; s=new S; s.x++; return s.x; // Ok, no initializer so x is mutable ");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code, 0));
+    }
+
+    @Test public void testVar5() {
+        CodeGen code = new CodeGen("struct S{int x;}; !S? !s; s=new S{x=3;}; s.x++; return s.x; // Ok, no initializer so x is mutable ");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 4;", code.print());
+        assertEquals("4", Eval2.eval(code, 0));
+    }
+
+    @Test public void testVar6() {
+        CodeGen code = new CodeGen("struct S{int x;}; ~S s = new S; s.x++; return s.x; // Error initializer so x is immutable ");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar7() {
+        CodeGen code = new CodeGen("struct S{int x;}; ~S s = new S{x=3;}; s.x++; return s.x; // Error initializer so x is immutable ");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar8() {
+        CodeGen code = new CodeGen("struct S{int x;}; !S !s=new S; s.x++; return s.x; // Ok, has '!' so s.x is mutable ");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code, 0));
+    }
+
+    @Test public void testVar9() {
+        CodeGen code = new CodeGen("struct S{int x;}; var s=new S; s.x++; return s.x; // Ok, has var so s.x is mutable ");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 1;", code.print());
+        assertEquals("1", Eval2.eval(code, 0));
+    }
+
+    @Test public void testVar10() {
+        CodeGen code = new CodeGen("struct S{int x;}; ~S s=new S; s.x++; return s.x; // Error, has val so x is immutable ");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar11() {
+        CodeGen code = new CodeGen("""
+struct Bar { int x; };
+!Bar !bar = new Bar;
+bar.x = 3; // Ok, bar is mutable
+
+struct Foo { !Bar? !bar; int y; };
+!Foo !foo = new Foo { bar = bar; };
+foo.bar = bar; // Ok foo is mutable
+foo.bar.x++;   // Ok foo and foo.bar and foo.bar.x are all mutable
+
+~Foo xfoo = foo; // Throw away mutability
+xfoo.bar.x++;   // Error, cannot mutate through xfoo
+return xfoo.bar.x;
+ """);
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar12() {
+        CodeGen code = new CodeGen("""
+struct Bar { int x; };
+!Bar !bar = new Bar;
+bar.x = 3; // Ok, bar is mutable
+
+struct Foo { !Bar? !bar; int y; };
+!Foo !foo = new Foo;
+foo.bar = bar; // Ok bar is mutable
+foo.bar.x++;   // Ok foo and foo.bar and foo.bar.x are all mutable
+
+~Foo xfoo = foo;        // Throw away mutability
+int x4 = xfoo.bar.x;   // Ok to read through xfoo, gets 4
+foo.bar.x++;           // Bumps to 5
+int x5 = xfoo.bar.x;   // Ok to read through xfoo, gets 5
+return x4*10+x5;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 45;", code.print());
+        assertEquals("45", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testVar13() {
+        CodeGen code = new CodeGen("""
+int i,i++;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Redefining name 'i'",e.getMessage()); }
+    }
+
+
+    @Test
+    public void testVar14() {
+        CodeGen code = new CodeGen("""
+struct B {};
+struct A { !B !b; };
+A x = new A {
+    return b; // read before init
+    b = new B;
+};
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Cannot read uninitialized field 'b'",e.getMessage()); }
+    }
+
+    @Test
+    public void testVar15() {
+        CodeGen code = new CodeGen("""
+struct B {};
+struct A { !B !b; };
+return new A {
+    if (arg) b = new B; // Constructor ends with partial init of b
+}.b;
+""");
+        try { code.parse(); fail(); }
+        catch( Exception e ) { assertEquals("'A' is not fully initialized, field 'b' needs to be set in a constructor",e.getMessage()); }
+    }
+
+    @Test
+    public void testVar16() {
+        CodeGen code = new CodeGen(
+"""
+struct S{};
+val x = 1;
+~S s = new S{x = 2;};
+return x;
+"""
+);
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Cannot reassign final 'x'",e.getMessage()); }
+    }
+
+    @Test
+    public void testVar17() {
+        CodeGen code = new CodeGen(
+"""
+struct Person {
+    bool focused;
+};
+val focus = { !Person p ->
+    p.focused = true;
+};
+!Person !me; // !Person !me = new Person;
+focus(me);
+return me;
+"""
+);
+        try { code.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected =expression: ;",e.getMessage()); }
+    }
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testTrinary0() {
+        CodeGen code = new CodeGen("""
+return arg ? 1 : 2;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,1,2);", code.print());
+        assertEquals("2", Eval2.eval(code, 0));
+        assertEquals("1", Eval2.eval(code, 1));
+    }
+
+    @Test
+    public void testTrinary1() {
+        CodeGen code = new CodeGen("""
+return arg ? 0 : arg;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 0;", code.print());
+        assertEquals("0", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testTrinary2() {
+        CodeGen code = new CodeGen("""
+struct Bar { int x; };
+var b = arg ? new Bar : null;
+return b ? b.x++ + b.x++ : -1;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,((.x<<1)+1),-1);", code.print());
+        assertEquals("-1", Eval2.eval(code, 0));
+        assertEquals("1", Eval2.eval(code, 1));
+    }
+
+    @Test
+    public void testTrinary3() {
+        CodeGen code = new CodeGen("""
+struct Bar { int x; };
+var b = arg ? new Bar;
+return b ? b.x++ + b.x++ : -1;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,((.x<<1)+1),-1);", code.print());
+        assertEquals("-1", Eval2.eval(code, 0));
+        assertEquals("1", Eval2.eval(code, 1));
+    }
+
+    @Test
+    public void testTrinary4() {
+        // This test case will benefit from an unzipping transformation
+        CodeGen code = new CodeGen("""
+struct Bar { !Bar? !next; int x; };
+var b = arg ? new Bar { next = (arg==2) ? new Bar{x=2;}; x=1; };
+return b ? b.next ? b.next.x : b.x; // parses "b ? (b.next ? b.next.x : b.x) : 0"
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,.x,0,.x);", code.print());
+        assertEquals("0", Eval2.eval(code, 0));
+        assertEquals("1", Eval2.eval(code, 1));
+        assertEquals("2", Eval2.eval(code, 2));
+    }
+
+    @Test
+    public void testTrinary5() {
+        CodeGen code = new CodeGen("""
+flt f=arg?1:1.2;
+return f;   // missing widening
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Region,1.0f,1.2);", code.print());
+        assertEquals("1.2", Eval2.eval(code,  0));
+    }
+
+
+    @Test
+    public void testTrinary6() {
+        CodeGen code = new CodeGen("""
+struct S{};
+return arg ? 7 : new S;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("No common type amongst int and reference",e.getMessage()); }
+    }
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testFor0() {
+        CodeGen code = new CodeGen("""
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", code.print());
+        assertEquals("3", Eval2.eval(code, 3));
+        assertEquals("45", Eval2.eval(code, 10));
+    }
+    @Test
+    public void testFor1() {
+        CodeGen code = new CodeGen("""
+int sum=0, i=0;
+for( ; i<arg; i++ )
+    sum += i;
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", code.print());
+        assertEquals("3", Eval2.eval(code, 3));
+        assertEquals("45", Eval2.eval(code, 10));
+    }
+    @Test
+    public void testFor2() {
+        CodeGen code = new CodeGen("""
+int sum=0;
+for( int i=0; ; i++ ) {
+    if( i>=arg ) break;
+    sum += i;
+}
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", code.print());
+        assertEquals("3", Eval2.eval(code, 3));
+        assertEquals("45", Eval2.eval(code, 10));
+    }
+    @Test
+    public void testFor3() {
+        CodeGen code = new CodeGen("""
+int sum=0;
+for( int i=0; i<arg; )
+    sum += i++;
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", code.print());
+        assertEquals("3", Eval2.eval(code, 3));
+        assertEquals("45", Eval2.eval(code, 10));
+    }
+    @Test
+    public void testFor4() {
+        CodeGen code = new CodeGen("""
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return i;
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Undefined name 'i'",e.getMessage()); }
+    }
+    @Test
+    public void testFor5() {
+        CodeGen code = new CodeGen("""
+for(;;arg++;) {}
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected Unexpected code after expression: ;",e.getMessage()); }
+    }
+
+
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testForward0() {
+        CodeGen code = new CodeGen("""
+struct A{
+    !B? !f1;
+    !B? !f2;
+};
+return new A;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return A;", code.print());
+        assertEquals("A{f1=null,f2=null}", Eval2.eval(code,0));
+    }
+
+    @Test
+    public void testForward1() {
+        CodeGen code = new CodeGen("""
+struct A {
+    !B?[]? !nil_array_of_b;
+    !B?[] !array_of_b;
+};
+return new A{array_of_b = new !B?[0]; }.array_of_b;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return []*B?;", code.print());
+        assertEquals("*B {... }?[]", Eval2.eval(code,0));
+    }
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testLinkedList2() {
+        CodeGen code = new CodeGen("""
+struct LLI { !LLI? !next; int i; };
+!LLI? !head = null;
+while( arg-- )
+    head = new LLI { next=head; i=arg; };
+int sum=0;
+var ptr = head; // A read-only ptr, to be assigned from read-only next fields
+for( ; ptr; ptr = ptr.next )
+    sum += ptr.i;
+return sum;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return Phi(Loop,0,(Phi_sum+.i));", code.print());
+        assertEquals("45", Eval2.eval(code, 10));
+    }
+
+    @Test
+    public void sieveOfEratosthenes() {
+        CodeGen code = new CodeGen(
+"""
+var ary = new bool[arg], primes = new int[arg];
+var nprimes=0, p=0;
+// Find primes while p^2 < arg
+for( p=2; p*p < arg; p++ ) {
+    // skip marked non-primes
+    while( ary[p] ) p++;
+    // p is now a prime
+    primes[nprimes++] = p;
+    // Mark out the rest non-primes
+    for( int i = p + p; i < ary#; i += p )
+        ary[i] = true;
+}
+// Now just collect the remaining primes, no more marking
+for( ; p < arg; p++ )
+    if( !ary[p] )
+        primes[nprimes++] = p;
+// Copy/shrink the result array
+var !rez = new int[nprimes];
+for( int j=0; j<nprimes; j++ )
+    rez[j] = primes[j];
+return rez;
+""");
+        code.driver(CodeGen.Phase.Schedule);
+        assertEquals("return []i64;", code.print());
+        assertEquals("i64[ 2,3,5,7,11,13,17,19]",Eval2.eval(code, 20));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter18Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter18Test.java
new file mode 100644
index 00000000..e26edb7e
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter18Test.java
@@ -0,0 +1,544 @@
+package com.seaofnodes.simple;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.node.*;
+
+
+import com.seaofnodes.simple.codegen.CodeGen.Phase;
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import static org.junit.Assert.fail;
+
+public class Chapter18Test {
+    @Test public void testNeverExitLoopDepth() {
+        String[] sources = {
+            "if(arg) while(1) {} return 7;",
+            "if(arg==1) while(1) {} if(arg==2) while(1) {} return 7;",
+            "while(1) {}",
+            "int x=0; while(arg) { if(arg==2) while(1) { x++; } x++; arg--; } return x;"
+        };
+        for( String src : sources ) {
+            CodeGen code = new CodeGen(src).driver(CodeGen.Phase.LoopTree);
+            int[] nevers = {0};
+            code._stop.walk(n -> {
+                if( n instanceof FunNode fun )
+                    assertEquals("Function entry is outside its loops",0,fun.loopDepth());
+                if( n instanceof ReturnNode ret ) {
+                    assertEquals(ret.fun().loopDepth(),ret.loopDepth());
+                    assertEquals(ret.fun().loopDepth(),ret.cfg0().loopDepth());
+                }
+                if( n instanceof LoopNode loop && !(loop instanceof StartNode) &&
+                    loop.back() instanceof CProjNode back && back.in(0) instanceof NeverNode never ) {
+                    nevers[0]++;
+                    assertSame(loop,never.loop());
+                    assertSame(loop,back.loop());
+                    CProjNode exit = never.cproj(1-back._idx);
+                    CFGNode fun = loop;
+                    while( !(fun instanceof FunNode) ) fun=fun.idom();
+                    assertSame(fun.loop(),exit.loop());
+                    assertEquals(fun.loopDepth(),exit.loopDepth());
+                    assertTrue(loop.loopDepth()>fun.loopDepth());
+                }
+                return null;
+            });
+            assertTrue("Exercise a synthetic exit",nevers[0]>0);
+        }
+    }
+
+    @Test public void testFunctionLocalConstantChains() {
+        String src = "val f = { int x -> x ? f(x-1)*305420988+x/305420988 : 1; }; "+
+                     "val g = { int x -> x ? g(x-1)/305420988+x*305420988 : 1; }; "+
+                     "return f(arg)+g(arg);";
+        CodeGen code = new CodeGen(src);
+        code.driver(CodeGen.Phase.Schedule,"riscv","SystemV");
+        var owners = new java.util.IdentityHashMap<CFGNode,Boolean>();
+        code._stop.walk(n -> {
+            if( !(n instanceof com.seaofnodes.simple.node.cpus.riscv.AddIRISC add) ||
+                !(add.in(1) instanceof com.seaofnodes.simple.node.cpus.riscv.LUI upper) ||
+                ((TypeInteger)upper._con).value()+((add._imm12<<20)>>20)!=305420988 )
+                return null;
+            CFGNode fun = n.cfg0();
+            while( fun!=null && !(fun instanceof FunNode) ) fun = fun.idom();
+            assertTrue("Constant must belong to a function",fun instanceof FunNode);
+            assertNull("Share one constant chain within each function",owners.put(fun,true));
+            // Follow all parts of a machine constant, including shared inputs.
+            var todo = new java.util.ArrayList<Node>();
+            var seen = new java.util.IdentityHashMap<Node,Boolean>();
+            todo.add(n);
+            for( int j=0; j<todo.size(); j++ ) {
+                Node part = todo.get(j);
+                if( seen.put(part,true)!=null ) continue;
+                CFGNode owner = part.cfg0();
+                while( owner!=null && !(owner instanceof FunNode) ) owner = owner.idom();
+                assertSame("Every constant-building operation is function-local",fun,owner);
+                for( int i=1; i<part.nIns(); i++ ) {
+                    Node def = part.in(i);
+                    if( def==null || def instanceof CFGNode ) continue;
+                    assertTrue("Copies must register their data edges",def._outputs.find(part)!=-1);
+                    if( def._type.isConstant() ) todo.add(def);
+                }
+            }
+            return null;
+        });
+        assertTrue("Exercise constants shared across functions",owners.size()>=2);
+    }
+
+    @Test public void testReachableMixedReturns() {
+        for( String[] test : new String[][] {
+            {"if(arg) return 7; else return 2.5;", "No common type amongst int and f64"},
+            {"struct S { int x; }; if(arg) return new S; else return 0;",
+             "No common type amongst int and reference"}
+        } ) {
+            try {
+                new CodeGen(test[0]).driver(CodeGen.Phase.TypeCheck);
+                fail("Expected incompatible return types: " + test[0]);
+            } catch( Parser.ParseException e ) {
+                assertEquals(test[1],e.getMessage());
+            }
+        }
+    }
+
+
+    @Test public void testPrintingForwardReferenceScope() throws Exception {
+        new CodeGen("return 0;").parse();
+        var declared = TypeMemPtr.make(TypeStruct.open("PrintForward"));
+        var scope = new ScopeNode();
+        scope.define("ptr",declared,false,new ConstantNode(TypeInteger.ZERO),null);
+        Parser.TYPES.put("PrintForward",TypeMemPtr.make(TypeStruct.make("PrintForward",false)));
+        var field = Var.class.getDeclaredField("_type");
+        field.setAccessible(true);
+        var v = scope.var(0);
+        org.junit.Assert.assertSame(declared,field.get(v));
+        scope.toString();
+        org.junit.Assert.assertSame(declared,field.get(v));
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen(
+"""
+return 0;
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("return 0;", code._stop.toString());
+        assertEquals("0", Eval2.eval(code,  2));
+    }
+
+    @Test
+    public void testPhiParalleAssign() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+int b = 2;
+while(arg--) {
+  int t = a;
+  a = b;
+  b = t;
+}
+return a;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return Phi(Loop,1,Phi(Loop,2,Phi_a));", code._stop.toString());
+        assertEquals("1", Eval2.eval(code,  0));
+        assertEquals("2", Eval2.eval(code,  1));
+        assertEquals("1", Eval2.eval(code,  2));
+        assertEquals("2", Eval2.eval(code,  3));
+    }
+
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testType0() {
+        CodeGen code = new CodeGen(
+"""
+{int -> int}? x2 = null; // null function ptr
+return x2;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return null;", code._stop.toString());
+        assertEquals("null", Eval2.eval(code, 0 ) );
+    }
+
+    @Test
+    public void testFcn0() {
+        CodeGen code = new CodeGen(
+"""
+{int -> int}? sq = { int x ->
+    x*x;
+};
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return (Parm_x(sq,i64)*x);", code._stop.toString());
+        //assertEquals("{ int -> int #1}", Eval2.eval(code, 3));
+    }
+
+    @Test
+    public void testFcn1() {
+        CodeGen code = new CodeGen(
+"""
+var sq = { int x ->
+    x*x;
+};
+return sq(arg)+sq(3);
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("Stop[ return (#2+#2); return (Parm_x(sq,i64)*x); ]", code._stop.toString());
+        assertEquals("13", Eval2.eval(code, 2));
+    }
+
+    // Function scope test
+    @Test
+    public void testFcn2() {
+        CodeGen code = new CodeGen(
+"""
+int cnt=1;
+return { -> cnt; };
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("Variable 'cnt' is out of function scope and must be a final constant",e.getMessage()); }
+    }
+
+    // Function scope test
+    @Test
+    public void testFcn3() {
+        CodeGen code = new CodeGen(
+"""
+val cnt=2;
+return { -> cnt; }();
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("return 2;", code._stop.toString());
+        assertEquals("2", Eval2.eval(code, 0));
+    }
+
+    // Function variables
+    @Test
+    public void testFcn4() {
+        CodeGen code = new CodeGen(
+"""
+var fcn = arg ? { int x -> x*x; } : { int x -> x+x; };
+return fcn(3);
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("Stop[ return #2; return (Parm_x($fun21,i64)*x); return (Parm_x($fun22,i64)<<1); ]", code._stop.toString());
+        assertEquals("6", Eval2.eval(code, 0));
+        assertEquals("9", Eval2.eval(code, 1));
+    }
+
+    // Recursive factorial test
+    @Test
+    public void testFcn5() {
+        CodeGen code = new CodeGen("val fact = { int x -> x <= 1 ? 1 : x*fact(x-1); }; return fact(arg);");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("Stop[ return #2; return Phi(Region,1,(Parm_x(fact,i64)*#2)); ]", code._stop.toString());
+        assertEquals( "1", Eval2.eval(code, 0));
+        assertEquals( "1", Eval2.eval(code, 1));
+        assertEquals( "2", Eval2.eval(code, 2));
+        assertEquals( "6", Eval2.eval(code, 3));
+        assertEquals("24", Eval2.eval(code, 4));
+    }
+
+    @Test
+    public void testFcn6() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int i; };
+val newS = { int x -> return new S { i=x; }; };
+return newS(1).i;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 1;", code._stop.toString());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+    // Double forward reference
+    @Test
+    public void testFcn7() {
+        CodeGen code = new CodeGen(
+"""
+if( arg ? f : g ) return 1;
+val f = {->1;};
+val g = {->2;};
+return 2;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 1;", code._stop.toString());
+        assertEquals("1", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testFcn8() {
+        CodeGen code = new CodeGen(
+"""
+{int -> int}? !i2i = null;
+var id = {{int->int} f-> return f;};
+for(;;) {
+    if (i2i) return i2i(arg);
+    var x = {int i-> return i;};
+    arg = x(3);
+    i2i = id(x);
+}
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("Stop[ return #2; return Parm_i(x,i64); ]", code._stop.toString());
+        assertEquals("3", Eval2.eval(code,  0));
+    }
+
+    @Test
+    public void testFcn9() {
+        CodeGen code = new CodeGen(
+"""
+{int -> int}? !i2i = null;
+for(;;) {
+    if (i2i) return i2i(arg);
+    var x = {int i-> return i;};
+    arg = x(3);
+}
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("return Top;", code._stop.toString());
+        assertNull(Eval2.eval(code,0)); // Infinite loop: i2i remains null.
+    }
+
+
+    @Test
+    public void testFcn10() {
+        CodeGen code = new CodeGen(
+"""
+struct Person {
+  int age;
+};
+
+val fcn = { !Person?[] !ps, int x ->
+  val tmp = ps[x];
+  if( ps[x] )
+    ps[x].age++;
+};
+
+var ps = new !Person?[2];
+ps[0] = new Person;
+ps[1] = new Person;
+return fcn(ps,1);
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("return 0;", code._stop.toString());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    // Function break
+    @Test
+    public void testErr1() {
+        CodeGen code = new CodeGen(
+"""
+for(;;) {
+    val f = { ->
+        break;
+    };
+    f();
+    return 2;
+}
+return 1;
+""");
+        try { code.driver(CodeGen.Phase.FinalizeIR); fail(); }
+        catch( Exception e ) { assertEquals("No active loop for a break or continue",e.getMessage()); }
+    }
+
+    // Calling and inlining a null function
+    @Test
+    public void testErr2() {
+        CodeGen code = new CodeGen(
+"""
+{int -> int}? !i2i = { int i -> return i; };
+for(;;) {
+    if (i2i(2) == arg) break;
+    i2i = null;
+}
+return 0;
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Might be null calling { i64 -> i64 #21}?",e.getMessage()); }
+    }
+
+
+    @Test
+    public void testErr3() {
+        CodeGen code = new CodeGen(
+"""
+val f = { int i, int j -> return i+j; };
+return f();
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Expecting 2 arguments, but found 0",e.getMessage()); }
+    }
+
+
+    @Test
+    public void testErr4() {
+        CodeGen code = new CodeGen(
+"""
+struct S {
+    {int} f = { -> x(); return 0; }; // Do not let fref x be a field
+};
+val x = { -> return 1; };
+!S? !s = null;
+for(;;) {
+    if (s) return s.x;
+}
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("Accessing unknown field 'x' from '*S'",e.getMessage()); }
+    }
+
+    @Test
+    public void testErr5() {
+        CodeGen code = new CodeGen(
+"""
+val g = { ->
+    g();
+};
+return g();
+""");
+        try { code.driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { assertEquals("No defined return type",e.getMessage()); }
+    }
+
+
+    // Mutual recursion.  Fails without SCCP to lift the recursive return types.
+    @Ignore @Test
+    public void testFcnMutRec() {
+        CodeGen code = new CodeGen(
+"""
+val is_even = { int x -> x ? is_odd (x-1) : true ; };
+val is_odd  = { int x -> x ? is_even(x-1) : false; };
+return is_even(arg);
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        assertEquals("Stop[ return is_even( arg); return Phi(Region,Phi(Region,is_even( ((Parm_x(is_even,int,arg,Sub)-1)-1)),0),1); ]", code._stop.toString());
+        assertEquals("1", Eval2.eval(code, 0));
+        assertEquals("0", Eval2.eval(code, 1));
+        assertEquals("1", Eval2.eval(code, 2));
+        assertEquals("0", Eval2.eval(code, 3));
+    }
+
+    // Forward ref to 'x' means that
+    @Ignore @Test
+    public void testForwardRef1() {
+        CodeGen code = new CodeGen(
+"""
+struct S {
+    { int } f = { -> return x(); };
+};
+val x = { -> return 1; };
+!S? !s = null;
+for(;;) {
+    if (s) return s.f;
+}
+""");
+        code.driver(CodeGen.Phase.Schedule);
+        assertEquals("return 0;", code._stop.toString());
+        assertEquals("0", Eval2.eval(code,  0));
+    }
+
+    // Inline hidden called more than once
+    @Test
+    public void testInline() {
+        CodeGen code = new CodeGen(
+"""
+{int->int}?! i2i = {int i->return i;};
+{{int->int}->{int->int}}! f2f = {{int->int} f->return f;};
+val o = i2i;
+if (arg) i2i = null;
+if (i2i) return i2i(arg);
+return f2f(o)(1);
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("Stop[ return Phi(Region,#2,1); return Parm_i(i2i.o,i64); ]", code._stop.toString());
+        assertEquals("1", Eval2.eval(code,  2));
+    }
+
+    @Test
+    public void testOperField() {
+        CodeGen code = new CodeGen(
+"""
+struct Person {
+    int coffee_count;
+};
+!Person !p = new Person;
+p.coffee_count += 1;
+return p.coffee_count;
+""");
+        code.driver(Phase.LocalSched);
+        assertEquals("return 1;", code._stop.toString());
+        assertEquals("1", Eval2.eval(code,  2));
+    }
+
+    static final String CALL_MEMORY = """
+        struct S { int x; int y; };
+        val bump = { !S !s, int d -> int old=s.x; s.x=old+d; return old; };
+        !S !a = new S { x=10; y=7; };
+        !S !b = new S { x=20; y=9; };
+        !S !p=a; if (arg) p=b;
+        int before=p.x;
+        int old=bump(p,3);
+        int after=p.x;
+        bump(a,5);
+        return before*1000000+old*10000+after*100+a.x+a.y;
+        """;
+
+    @Test public void testCallMemory() {
+        var code = new CodeGen(CALL_MEMORY).driver(CodeGen.Phase.FinalizeIR);
+        int[] calls={0};
+        code._stop.walk(n -> { if(n instanceof CallNode) calls[0]++; return null; });
+        assertEquals(2,calls[0]); // Keep real calls so this checks scheduling across them.
+        assertEquals("10101325",Eval2.eval(code,0));
+        assertEquals("20202322",Eval2.eval(code,1));
+        code._stop.walk(n -> {
+            if(n instanceof CallNode call) {
+                assertEquals(5,call.nIns()); // No scheduling edges may become extra arguments.
+                assertTrue(call.fptr()._type instanceof TypeFunPtr);
+            }
+            return null;
+        });
+    }
+
+    static final String RECURSIVE_MEMORY = """
+        struct S { int x; };
+        val rec = { !S !s, int n ->
+            if (n==0) return s.x;
+            int before=s.x;
+            s.x=before+1;
+            return before+rec(s,n-1);
+        };
+        !S !s=new S { x=10; };
+        int value=rec(s,arg);
+        return value*100+s.x;
+        """;
+
+    @Test public void testRecursiveMemory() {
+        var code = new CodeGen(RECURSIVE_MEMORY).driver(CodeGen.Phase.FinalizeIR);
+        for(int n=0; n<7; n++)
+            assertEquals(Long.toString((10L*(n+1)+n*(n+1)/2)*100+10+n),Eval2.eval(code,n));
+    }
+
+    static final String INLINE_MEMORY = """
+        struct S { int x; int y; };
+        val make = { !S s ->
+            S t = new S { x=s.x+1; y=3; };
+            s.y=9;
+            return t;
+        };
+        !S !a = new S { x=arg+40; y=7; };
+        S t=make(a);
+        return a.x*10000+a.y*100+t.x+t.y;
+        """;
+
+    @Test public void testInlineAllocationMemory() {
+        var code = new CodeGen(INLINE_MEMORY).driver(CodeGen.Phase.FinalizeIR);
+        assertNull(code._stop.walk(n -> n instanceof CallNode ? n : null));
+        assertEquals("400944",Eval2.eval(code,0));
+        assertEquals("420946",Eval2.eval(code,2));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter19Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter19Test.java
new file mode 100644
index 00000000..303cfda2
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter19Test.java
@@ -0,0 +1,507 @@
+package com.seaofnodes.simple;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+
+
+import com.seaofnodes.simple.codegen.CodeGen.Phase;
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter19Test {
+    @Test public void testPrintingFunctionLookup() {
+        var code = new CodeGen("return 0;").parse();
+        var tfp = TypeFunPtr.make((byte)2,false,new Type[]{TypeInteger.constant(987654)},TypeInteger.constant(123456),1L<<30);
+        var con = new ConstantNode(tfp);
+        var call = new CallNode(null,code._start,con,con);
+        // Diagnostic lookup may construct/intern the return-erased linker key.
+        con.toString();
+        org.junit.Assert.assertNull(call.name());
+
+        var fun = new FunNode(null,tfp,"printerTarget");
+        fun._name = "printerTarget";
+        fun.addDef(code._start);
+        code.link(fun);
+        var otherReturn = tfp.makeFrom(TypeInteger.constant(654321));
+        org.junit.Assert.assertSame(fun,code._link(otherReturn));
+        org.junit.Assert.assertTrue(con.toString().contains("printerTarget"));
+        assertEquals("printerTarget",call.name());
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen("""
+return 0;
+""");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 0;", code._stop.toString());
+        assertEquals("0", Eval2.eval(code,  2));
+    }
+
+
+    @Test
+    public void testString() throws IOException {
+        String src =
+"""
+struct String {
+    u8[] !cs;
+    int _hashCode;
+};
+
+// Compare two Strings
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+// Return the String hashCode (cached, and never 0)
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    for( int i=0; i< self.cs#; i++ )
+        hash = hash*31 + self.cs[i];
+    if( !hash ) hash = 123456789;
+    return hash;
+};
+""";
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.LocalSched);
+        assertEquals("Stop[ return Phi(Region,1,0,0,1); return Phi(Region,._hashCode,Phi(Region,123456789,Phi(Loop,0,(.[]+((Phi_hash<<5)-Phi_hash))))); ]", code._stop.toString());
+        //assertEquals("-4898613127354160978", Eval2.eval(code,  2));
+    }
+
+    @Test
+    public void testBasic0() {
+        CodeGen code = new CodeGen("return 0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return 0;", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic1() {
+        CodeGen code = new CodeGen("return arg+1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (inc,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic2() {
+        CodeGen code = new CodeGen("return -17;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return -17;", code._stop.toString());
+    }
+
+
+    @Test
+    public void testBasic3() {
+        CodeGen code = new CodeGen("return arg==1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (set==,(cmp,arg));", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic4() {
+        CodeGen code = new CodeGen("return arg<<1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (shli,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic5() {
+        CodeGen code = new CodeGen("return arg >> 1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (sari,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic6() {
+        CodeGen code = new CodeGen("return arg >>> 1;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (shri,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic7() {
+        CodeGen code = new CodeGen("return arg / 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (div,arg,2);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic8() {
+        CodeGen code = new CodeGen("return arg * 6;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (muli,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic9() {
+        CodeGen code = new CodeGen("return arg & 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (andi,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic10() {
+        CodeGen code = new CodeGen("return arg | 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (ori,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic11() {
+        CodeGen code = new CodeGen("return arg ^ 2;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (xori,arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic12() {
+        CodeGen code = new CodeGen("return arg + 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (addf,(cvtf,arg),2.0f);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic13() {
+        CodeGen code = new CodeGen("return arg - 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (subf,(cvtf,arg),2.0f);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic14() {
+        CodeGen code = new CodeGen("return arg * 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (mulf,(cvtf,arg),2.0f);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic15() {
+        CodeGen code = new CodeGen("return arg / 2.0;").driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (mulf,(cvtf,arg),0.5f);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic16() {
+        CodeGen code = new CodeGen(
+"""
+int arg1 =  arg + 1;
+return arg1 / arg;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (div,(inc,arg),arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testBasic17() {
+        CodeGen code = new CodeGen(
+"""
+int arg1 =  arg + 1;
+return arg1 * arg;
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (mul,(inc,arg),arg);", code._stop.toString());
+    }
+
+    @Test
+    public void testToFloat() {
+        CodeGen code = new CodeGen("""
+int a = arg;
+return a + 2.0;
+"""
+        ).driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (addf,(cvtf,arg),2.0f);", code._stop.toString());
+    }
+
+    @Test
+    public void testIfStmt() {
+        CodeGen code = new CodeGen(
+"""
+int a = 1;
+if (arg == 1)
+    a = arg+2;
+else {
+    a = arg-3;
+}
+return a;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Phi(Region,(addi,arg),(addi,arg));", code.print());
+    }
+
+    @Test
+    public void testIfMerge2() {
+        CodeGen code = new CodeGen(
+"""
+int a=arg+1;
+int b=arg+2;
+if( arg==1 )
+    b=b+a;
+else
+    a=b+1;
+return a+b;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (add,(add,Phi(Region,(shli,arg),arg),arg),Phi(Region,4,5));", code.print());
+    }
+
+    @Test
+    public void testLoop() {
+        CodeGen code = new CodeGen(
+"""
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return sum;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Phi(Loop,0,(add,Phi_sum,Phi(Loop,0,(inc,Phi_i))));", code.print());
+    }
+
+    @Test
+    public void testAlloc1() {
+        CodeGen code = new CodeGen(
+"""
+struct S { int a; !S? !c; };
+return new S;""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return S;", code.print());
+    }
+
+    @Test
+    public void testLea1() {
+        CodeGen code = new CodeGen("int x = arg/3; return arg+x+7;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (lea,arg,(div,arg,3));", code.print());
+    }
+
+    @Test
+    public void testLea2() {
+        CodeGen code = new CodeGen("int x = arg/3; return arg+x*4+7;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (lea,arg,(div,arg,3));", code.print());
+    }
+
+    @Test
+    public void testLea3() {
+        CodeGen code = new CodeGen("int x = arg/3; return x*4+arg;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return (lea,arg,(div,arg,3));", code.print());
+    }
+
+    @Test
+    public void testAlloc2() {
+        CodeGen code = new CodeGen("int[] !xs = new int[3]; xs[arg]=1; return xs[arg&1];");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testAlloc3() {
+        CodeGen code = new CodeGen("int[] !xs = new int[3]; xs[arg]=1; return xs[arg&1]+3;");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testArray1() {
+        CodeGen code = new CodeGen(
+"""
+int[] !ary = new int[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<ary#; i++ )
+    ary[i] = i;
+// Fill [0,1,3,6,10,...]
+for( int i=0; i<ary#-1; i++ )
+    ary[i+1] += ary[i];
+return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testArray2() {
+        CodeGen code = new CodeGen(
+"""
+flt[] !A = new flt[arg], !B = new flt[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<A#; i++ )
+    A[i] = i;
+for( int i=0; i<A#; i++ )
+    B[i] += A[i];
+return 0;
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return 0;", code.print());
+    }
+
+    @Test
+    public void testArray3() {
+        CodeGen code = new CodeGen(
+"""
+byte[] !A = new byte[arg];
+for( int i=0; i<A#; i++ )
+    A[i]++;
+return A[1];
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return .[];", code.print());
+    }
+
+    @Test
+    public void testNewton() throws IOException {
+        String src =
+"""
+val test_sqrt = { flt x ->
+    flt epsilon = 1e-15;
+    flt guess = x;
+    while( 1 ) {
+        flt next = (x/guess + guess)/2;
+        if( guess-epsilon <= next & next <= guess+epsilon ) return guess;
+        //if( guess==next ) return guess;
+        guess = next;
+    }
+};
+flt farg = arg;  return test_sqrt(farg);
+""";
+        CodeGen code = new CodeGen(src).driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return Phi(Loop,(cvtf,arg),(mulf,(addf,(divf,cvtf,Phi_guess),Phi_guess),0.5f));", code.print());
+    };
+
+
+    @Test
+    public void sieveOfEratosthenes() throws IOException {
+        String src =
+"""
+val sieve = { int N ->
+    // The main Sieve array
+    bool[] !ary = new bool[N];
+    // The primes less than N
+    u32[] !primes = new u32[N>>1];
+    // Number of primes so far, searching at index p
+    int nprimes = 0, p=2;
+    // Find primes while p^2 < N
+    while( p*p < N ) {
+        // skip marked non-primes
+        while( ary[p] ) p++;
+        // p is now a prime
+        primes[nprimes++] = p;
+        // Mark out the rest non-primes
+        for( int i = p + p; i < ary#; i+= p )
+            ary[i] = true;
+        p++;
+    }
+
+    // Now just collect the remaining primes, no more marking
+    for( ; p < N; p++ )
+        if( !ary[p] )
+            primes[nprimes++] = p;
+
+    // Copy/shrink the result array
+    u32[] !rez = new u32[nprimes];
+    for( int j=0; j < nprimes; j++ )
+        rez[j] = primes[j];
+    return rez;
+};
+""";
+        CodeGen code = new CodeGen(src).driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("return []u32;", code.print());
+        //assertEquals("u32[ 2,3,5,7,11,13,17,19]",Eval2.eval(code, 20));
+    }
+
+
+    @Test
+    public void testFcn1() {
+        CodeGen code = new CodeGen(
+"""
+val fcn = arg ? { int x -> x*x; } : { int x -> x+x; };
+return fcn(2)*10 + fcn(3);
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("Stop[ return (add,#2,(muli,#2)); return (mul,Parm_x($fun21,i64),x); return (shli,Parm_x($fun22,i64)); ]", code.print());
+    }
+
+    @Test
+    public void testFcn2() {
+        CodeGen code = new CodeGen(
+"""
+val sq = { int x -> x*x; };
+return sq(arg) + sq(3);
+""");
+        code.driver(Phase.LocalSched,"x86_64_v2", "SystemV");
+        assertEquals("Stop[ return (add,#2,#2); return (mul,Parm_x(sq,i64),x); ]", code.print());
+    }
+
+    @Test public void testSelectedMemory() {
+        for( String cpu : new String[]{"x86_64_v2","riscv","arm"} )
+            for( String src : new String[]{Chapter10Test.NESTED_MEMORY,Chapter16Test.CONSTRUCTOR_MEMORY,
+                                          Chapter18Test.CALL_MEMORY,Chapter18Test.RECURSIVE_MEMORY} ) {
+                var code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+                var aliases = memoryPhis(code._stop);
+                code.loopTree().driver(CodeGen.Phase.Select,cpu,"SystemV");
+                assertEquals(aliases,memoryPhis(code._stop));
+                code.driver(CodeGen.Phase.Schedule).localSched();
+                code._stop.walk(n -> {
+                    if( !(n instanceof CFGNode) && !(n instanceof ProjNode) )
+                        assertTrue(n.in(0) instanceof CFGNode);
+                    if( n instanceof NewNode nn ) {
+                        assertEquals(2,((TypeTuple)nn._type)._types.length);
+                        assertTrue(nn.mem() instanceof MemMergeNode);
+                        assertNull(nn.mem().in(1)); // Partial allocation input.
+                        nn.cacheRegs(code);
+                        MachNode mach = (MachNode)nn;
+                        assertNull(mach.regmap(1));
+                        assertNotNull(mach.regmap(2));
+                        assertNotNull(mach.outregmap(0));
+                        assertNull(mach.outregmap(1));
+                    }
+                    if( n instanceof CallNode call ) {
+                        assertEquals(4,call.nIns()); // ctrl, memory, two args; direct target is embedded.
+                    }
+                    return null;
+                });
+            }
+    }
+
+    private static java.util.ArrayList<String> memoryPhis(Node stop) {
+        var phis = new java.util.ArrayList<String>();
+        // Count only definitions reachable from Stop, as instruction selection does.
+        // A dead Phi cycle can still appear through the reverse use edges.
+        var seen = new java.util.BitSet();
+        var work = new java.util.ArrayList<Node>();
+        work.add(stop);
+        for( int i=0; i<work.size(); i++ ) {
+            Node n = work.get(i);
+            if( n==null || seen.get(n._nid) ) continue;
+            seen.set(n._nid);
+            for( Node def : n._inputs ) work.add(def);
+            if( n instanceof MemPhiNode phi ) phis.add("alias:"+phi._alias);
+            if( n instanceof BulkMemPhiNode phi ) phis.add("bulk:"+phi._aliases);
+            assertFalse(n instanceof PhiNode && n.isMem() &&
+                !(n instanceof MemPhiNode) && !(n instanceof BulkMemPhiNode) && !(n instanceof ParmNode));
+        }
+        java.util.Collections.sort(phis);
+        return phis;
+    }
+
+    @Test public void testFoldedReadBeforeWrites() {
+        var code = new CodeGen("""
+            struct S { int x; };
+            !S !a = new S { x=11; }; !S !b = new S { x=22; };
+            !S !p = a; if( arg ) p = b;
+            int before = p.x + arg;
+            a.x=33; b.x=44;
+            return before;
+            """).driver(CodeGen.Phase.LocalSched,"x86_64_v2","SystemV");
+        var read = (MemOpNode)code._stop.walk(n ->
+            n instanceof com.seaofnodes.simple.node.cpus.x86_64_v2.AddMemX86 ? n : null);
+        assertNotNull(read);
+        int writes = 0;
+        for( Node use : read.antiDeps() )
+            if( use instanceof MemOpNode st && st.isMem() ) {
+                assertSame(read.cfg0(),st.cfg0());
+                assertTrue(st._inputs.find(read)>=0);
+                assertTrue(read.cfg0()._outputs.find(read)<st.cfg0()._outputs.find(st));
+                assertNull(((MachNode)st).regmap(st._inputs.find(read)));
+                writes++;
+            }
+        assertEquals(1,writes); // The next Store follows this first clobber through memory.
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter20Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter20Test.java
new file mode 100644
index 00000000..ba93a440
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter20Test.java
@@ -0,0 +1,430 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.print.ASMPrinter;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter20Test {
+    @Test public void testFlagSpills() throws Exception {
+        com.seaofnodes.simple.codegen.FlagSpillTestSupport.run();
+    }
+
+    @Test public void testAllocatorTopPhi() { com.seaofnodes.simple.codegen.RegAllocTestSupport.topPhi(); }
+
+    @Test public void testNeverReturnAllocation() {
+        String[] sources = {
+            // A real integer return merged with a synthetic exit.
+            "if(arg) while(1) {} return arg+1;",
+            // TOP must not widen a non-null pointer or constrain a float register.
+            "struct S { int x; }; !S !s=new S; if(arg) while(1) {} return s;",
+            "if(arg) while(1) {} return 1.5;",
+            // Several synthetic exits into the same return.
+            "if(arg==1) while(1) {} if(arg==2) while(1) {} return arg+3;",
+            // No real return, including a merge of only synthetic exits.
+            "while(1) { arg+=1; }",
+            "if(arg) while(1) {} while(1) {}",
+            // Loop-carried memory and scalar self-conflicts exercise spilling.
+            "struct S { int x; int y; }; !S !a=new S; if(arg) while(1) { a.x+=arg; a.y+=a.x; } return a.x+a.y;"
+        };
+        for( String target : new String[]{"x86_64_v2","riscv","arm"} )
+            for( String src : sources ) {
+                CodeGen code = new CodeGen(src).driver(CodeGen.Phase.RegAlloc,target,"SystemV");
+                com.seaofnodes.simple.codegen.RegAllocTestSupport.checkRegisters(code);
+                assertNotNull(code._stop.walk(n -> {
+                    if( n._type!=com.seaofnodes.simple.type.Type.TOP ) return null;
+                    assertEquals(-1,code._regAlloc.regnum(n));
+                    for( var use : n.outs() )
+                        assertFalse(use instanceof com.seaofnodes.simple.node.SplitNode);
+                    return n;
+                }));
+                code.encode();
+            }
+    }
+
+    @Test public void testAllocatorFixedNeighbor() throws Exception { com.seaofnodes.simple.codegen.RegAllocTestSupport.uncoloredFixedNeighbor(); }
+
+    @Test public void testNarrowStoreMasks() {
+        for( String type : new String[]{"i8","u8","i16","u16"} ) {
+            CodeGen code = new CodeGen("struct S { "+type+" x; }; !S !s=new S; s.x=arg; return 0;")
+                .driver(CodeGen.Phase.RegAlloc,"x86_64_v2","SystemV");
+            int stores=0;
+            for( var bb : code._cfg )
+                for( var node : bb.outs() )
+                    if( node instanceof com.seaofnodes.simple.node.cpus.x86_64_v2.StoreX86 st ) {
+                        stores++;
+                        assertEquals(-1,st.regmap(4).nextReg((short)15));
+                    }
+            assertEquals(1,stores);
+        }
+    }
+
+    @Test public void testInlinedReturnValue() {
+        String src = """
+struct S { int x; };
+val f = { !S s -> s.x = g(); };
+val g = { -> 123; };
+!S !s = new S;
+return f(s);
+""";
+        // The entry of g can disappear before its Return is folded into f.
+        // Exercise both worklist orders; deleting the entry does not kill 123.
+        for( int seed=0; seed<64; seed++ ) {
+            CodeGen code = new CodeGen(src,com.seaofnodes.simple.type.TypeInteger.BOT,seed,true).driver(CodeGen.Phase.TypeCheck);
+            assertEquals("seed "+seed, "123", Eval2.eval(code,0));
+        }
+    }
+
+
+    @org.junit.Rule public final org.junit.rules.ErrorCollector _errors = new org.junit.rules.ErrorCollector();
+
+    @Test public void testAllocatorMasks() { com.seaofnodes.simple.codegen.RegAllocTestSupport.masks(); }
+    @Test public void testAllocatorUnion() { com.seaofnodes.simple.codegen.RegAllocTestSupport.union(); }
+    @Test public void testAllocatorCopyClobber() throws Exception { com.seaofnodes.simple.codegen.RegAllocTestSupport.copyClobber(); }
+    @Test public void testAllocatorCommutativePhi() { com.seaofnodes.simple.codegen.RegAllocTestSupport.commutativePhi(); }
+    @Test public void testAllocatorKills() { com.seaofnodes.simple.codegen.RegAllocTestSupport.killWithoutResult(); }
+    @Test public void testAllocatorDependencies() { com.seaofnodes.simple.codegen.RegAllocTestSupport.nullUseMask(); }
+    @Test public void testAllocatorCloneClass() { com.seaofnodes.simple.codegen.RegAllocTestSupport.cloneRegisterClass(); }
+
+    @Test public void testPrintingRegisters() throws Exception {
+        com.seaofnodes.simple.codegen.PrintRegTestSupport.check();
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() {
+        CodeGen code = new CodeGen("return 0;");
+        code.driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 0;", code._stop.toString());
+        assertEquals("0", Eval2.eval(code,  2));
+    }
+
+    // Collect differences so every target runs; JUnit still fails the test.
+    private void testTarget(String src, String cpu, String os, int spills, String stop) {
+        _errors.checkSucceeds(() -> { testCPU(src,cpu,os,spills,stop); return null; });
+    }
+
+    static void testCPU(String src, String cpu, String os, int spills, String stop) {
+        CodeGen code = new CheckedCodeGen(src);
+        code.driver(CodeGen.Phase.RegAlloc,cpu,os);
+        SpillStats.record(code,"Chapter20",cpu,os);
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+        if( stop!=null ) assertEquals(stop,code._stop.toString());
+    }
+
+    private void testAllCPUs( String src, int spills, String stop ) {
+        testTarget(src,"x86_64_v2", "SystemV",spills,stop);
+        testTarget(src,"riscv"    , "SystemV",spills,stop);
+        testTarget(src,"arm"      , "SystemV",spills,stop);
+    }
+
+    @Test public void testAlloc0() {
+        testTarget("return new u8[arg];","x86_64_v2","SystemV",4,"return []u8;");
+        testTarget("return new u8[arg];","riscv","SystemV",5,"return []u8;");
+        testTarget("return new u8[arg];","arm","SystemV",5,"return []u8;");
+    }
+
+    @Test public void testBasic1() {
+        String src = "return arg | 2;";
+        testTarget(src,"x86_64_v2", "SystemV",1,"return (ori,mov(arg));");
+        testTarget(src,"riscv"    , "SystemV",0,"return ( arg | #2 );");
+        testTarget(src,"arm"      , "SystemV",0,"return (ori,arg);");
+    }
+
+    @Test
+    public void testNewtonInteger() {
+        String src =
+"""
+// Newtons approximation to the square root
+val sqrt = { int x ->
+    int guess = x;
+    while( 1 ) {
+        int next = (x/guess + guess)/2;
+        if( next == guess ) return guess;
+        guess = next;
+    }
+};
+return sqrt(arg) + sqrt(arg+2);
+""";
+        testTarget(src,"x86_64_v2", "SystemV",40,null);
+        testTarget(src,"riscv"    , "SystemV",17,null);
+        testTarget(src,"arm"      , "SystemV",18,null);
+    }
+
+    @Test
+    public void testNewtonFloat() {
+        String src =
+"""
+// Newtons approximation to the square root
+val sqrt = { flt x ->
+    flt guess = x;
+    while( 1 ) {
+        flt next = (x/guess + guess)/2;
+        if( next == guess ) return guess;
+        guess = next;
+    }
+};
+flt farg = arg;
+return sqrt(farg) + sqrt(farg+2.0);
+""";
+        testTarget(src,"x86_64_v2", "SystemV",23,null);
+        testTarget(src,"riscv"    , "SystemV",18,null);
+        testTarget(src,"arm"      , "SystemV",18,null);
+    }
+
+    @Test
+    public void testAlloc2() {
+        String src = "int[] !xs = new int[3]; xs[arg]=1; return xs[arg&1];";
+        testTarget(src,"x86_64_v2","SystemV",3,"return .[];");
+        testTarget(src,"riscv","SystemV",6,"return .[];");
+        testTarget(src,"arm","SystemV",6,"return .[];");
+    }
+
+    @Test
+    public void testArray1() {
+        String src =
+"""
+int[] !ary = new int[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<ary#; i++ )
+    ary[i] = i;
+// Fill [0,1,3,6,10,...]
+for( int i=0; i<ary#-1; i++ )
+    ary[i+1] += ary[i];
+return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6
+""";
+        testTarget(src,"x86_64_v2", "SystemV",5,"return .[];");
+        testTarget(src,"riscv"    , "SystemV",7,"return (add,.[],(mul,.[],1000));");
+        testTarget(src,"arm"      , "SystemV",5,"return (add,.[],(mul,.[],1000));");
+    }
+
+    @Test
+    public void testString() {
+        String src = """
+struct String {
+    u8[] !cs;
+    int _hashCode;
+};
+
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    if( self.cs ) {
+        for( int i=0; i< self.cs#; i++ )
+            hash = hash*31 + self.cs[i];
+    }
+    if( !hash ) hash = 123456789;
+    return hash;
+};
+
+!String !s = new String { cs = new u8[17]; };
+s.cs[0] =  67; // C
+s.cs[1] = 108; // l
+hashCode(s);
+""";
+        testTarget(src,"x86_64_v2", "SystemV",9,null);
+        testTarget(src,"riscv"    , "SystemV",3,null);
+        testTarget(src,"arm"      , "SystemV",0,null);
+    }
+
+    @Test
+    public void testCast() {
+        String src = "struct Bar { int x; }; var b = arg ? new Bar;  return b ? b.x++ + b.x++ : -1;";
+        testTarget(src,"x86_64_v2","SystemV",1,null);
+        testTarget(src,"riscv","SystemV",2,null);
+        testTarget(src,"arm","SystemV",2,null);
+    }
+
+    @Test
+    public void testFltArg() {
+        String src = "return {int i, flt f, int j->return i+f+j;};";
+        testAllCPUs(src,0,null);
+    }
+
+    @Test
+    public void testFlags1() {
+        String src = """
+bool b1 = arg == 1;
+bool b2 = arg == 2;
+if (b2) if (b1) return 1;
+if (b1) return 2;
+return 0;
+""";
+        testTarget(src,"x86_64_v2", "SystemV",0,"return Phi(Region,1,2,0);");
+        testTarget(src,"riscv"    , "SystemV",0,"return Phi(Region,1,2,0);");
+        testTarget(src,"arm"      , "SystemV",0,"return Phi(Region,1,2,0);");
+    }
+
+    @Test
+    public void testFlags2() {
+        String src = """
+bool b1 = arg == 1;
+while (arg > 0) {
+    arg--;
+    if (b1) arg--;
+}
+return arg;
+""";
+        testTarget(src,"x86_64_v2", "SystemV",3,null);
+        testTarget(src,"riscv"    , "SystemV",2,null);
+        testTarget(src,"arm"      , "SystemV",2,null);
+    }
+    // Original Chapter 20 allocation workload, kept fixed for cohort comparisons.
+    @Test
+    public void testBrainfuck() {
+        var program = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.".getBytes(java.nio.charset.StandardCharsets.UTF_8);
+        var encoded = new StringBuilder("u8[] !program = new u8[").append(program.length).append("];");
+        for (int i = 0; i < program.length; i++) {
+            int value = program[i] & 0xFF;
+            encoded.append("program[").append(i).append("] = ").append(value).append(";");
+        }
+
+        String src = encoded + """
+
+int d = 0;
+u8[] !output = new u8[0];
+u8[] !data = new u8[100];
+
+for( int pc = 0; pc < program#; pc++ ) {
+    var command = program[pc];
+    if (command == 62) {
+        d++;
+    } else if (command == 60) {
+        d--;
+    } else if (command == 43) {
+        data[d]++;
+    } else if (command == 45) {
+        data[d]--;
+    } else if (command == 46) {
+        // Output a byte; increase the output array size
+        var old = output;
+        output = new u8[output# + 1];
+        for( int i = 0; i < old#; i++ )
+            output[i] = old[i];
+        output[old#] = data[d]; // Add the extra byte on the end
+    } else if (command == 44) {
+        data[d] = 42;
+    } else if (command == 91) {
+        if (data[d] == 0) {
+            for( int d = 1; d > 0; ) {
+                command = program[++pc];
+                if (command == 91) d++;
+                if (command == 93) d--;
+            }
+        }
+    } else if (command == 93) {
+        if (data[d]) {
+            for( int d = 1; d > 0; ) {
+                command = program[--pc];
+                if (command == 93) d++;
+                if (command == 91) d--;
+            }
+        }
+    }
+}
+return output;
+""";
+        testTarget(src,"x86_64_v2", "SystemV",40,null);
+        testTarget(src,"riscv"    , "SystemV",28,null);
+        testTarget(src,"arm"      , "SystemV",28,null);
+        //assertEquals("Hello World!\n", Eval2.eval(code, 0, 10000));
+    }
+    // Original Chapter 20 allocation workload, kept fixed for cohort comparisons.
+    @Test
+    public void testMergeSort() {
+        String src =
+"""
+// based on the top-down version from https://en.wikipedia.org/wiki/Merge_sort
+
+val merge_sort = { int[] !a, int[] !b, int n ->
+    copy_array(a, 0, n, b);
+    split_merge(a, 0, n, b);
+};
+
+val split_merge = { int[] !b, int begin, int end, int[] a ->
+    if (end - begin <= 1)
+        return 0;
+    int middle = (end + begin) / 2;
+    split_merge(a, begin, middle, b);
+    split_merge(a, middle, end, b);
+    merge(b, begin, middle, end, a);
+    return 0;
+};
+
+val merge = { int[] !b, int begin, int middle, int end, int[] a ->
+    int i = begin, j = middle;
+
+    for (int k = begin; k < end; k++) {
+        // && and ||
+        bool cond = false;
+        if (i < middle) {
+            if (j >= end)          cond = true;
+            else if (a[i] <= a[j]) cond = true;
+        }
+        if (cond) b[k] = a[i++];
+        else      b[k] = a[j++];
+    }
+};
+
+val copy_array = { int[] !a, int begin, int end, int[] b ->
+    for (int k = begin; k < end; k++)
+        b[k] = a[k];
+};
+
+int[] !a = new int[arg];
+int[] !b = new int[a#];
+
+for (int i = 0; i < a#; i++)
+    a[i] = a# - i;
+
+merge_sort(a, b, a#);
+
+return a;
+""";
+        testTarget(src,"x86_64_v2", "SystemV",52,null);
+        testTarget(src,"riscv"    , "SystemV",44,null);
+        testTarget(src,"arm"      , "SystemV",41,null);
+//assertEquals("int[ 1,2,3,4,5,6,7,8,9,10,11]", Eval2.eval(code, 11));
+    }
+
+
+    @Test public void testMemoryAllocation() {
+        for( String cpu : new String[]{"x86_64_v2","riscv","arm"} )
+            for( String src : new String[]{Chapter10Test.NESTED_MEMORY,Chapter16Test.CONSTRUCTOR_MEMORY,
+                                          Chapter18Test.CALL_MEMORY,Chapter18Test.RECURSIVE_MEMORY,
+                                          "int[] !a = new int[3]; a[arg]=arg; return a[0]+1;"} ) {
+                var code = new CodeGen(src).driver(CodeGen.Phase.RegAlloc,cpu,"SystemV");
+                com.seaofnodes.simple.codegen.RegAllocTestSupport.checkRegisters(code);
+                code._stop.walk(n -> {
+                    // Whole memory, precise Phis, and memory projections need no register.
+                    if( n._type instanceof com.seaofnodes.simple.type.TypeMem )
+                        assertEquals(-1,code._regAlloc.regnum(n));
+                    if( n instanceof com.seaofnodes.simple.node.NewNode nn ) {
+                        assertTrue(code._regAlloc.regnum(nn.proj(0))>=0);
+                        assertEquals(-1,code._regAlloc.regnum(nn.proj(1)));
+                    }
+                    return null;
+                });
+            }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter21AllocTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter21AllocTest.java
new file mode 100644
index 00000000..bab7a86a
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter21AllocTest.java
@@ -0,0 +1,55 @@
+package com.seaofnodes.simple;
+
+import java.io.IOException;
+import java.nio.file.*;
+import org.junit.Test;
+
+// Revised Chapter 20 examples introduced with native encoding.
+public class Chapter21AllocTest {
+    @Test
+    public void testNewtonInteger() {
+        String src =
+"""
+// Newtons approximation to the square root
+val sqrt = { int x ->
+    int guess = x;
+    while( 1 ) {
+        int next = (x/guess + guess)/2;
+        if( next == guess ) return guess;
+        guess = next;
+    }
+};
+return sqrt(arg) + sqrt(arg+2);
+""";
+        Chapter21Test.testCPU(src,"x86_64_v2", "Win64"  ,40,null);
+        Chapter21Test.testCPU(src,"riscv"    , "SystemV",19,null);
+        Chapter21Test.testCPU(src,"arm"      , "SystemV",19,null);
+    }
+
+    @Test
+    public void testNewtonFloat() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp"))
+            + "flt farg = arg; return test_sqrt(farg) + test_sqrt(farg+2.0);";
+        Chapter21Test.testCPU(src,"x86_64_v2", "SystemV",39,null);
+        Chapter21Test.testCPU(src,"riscv"    , "SystemV",17,null);
+        Chapter21Test.testCPU(src,"arm"      , "SystemV",18,null);
+    }
+
+    @Test
+    public void testArray1() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/array1.smp"));
+        Chapter21Test.testCPU(src,"x86_64_v2", "SystemV",-1,"return .[];");
+        Chapter21Test.testCPU(src,"riscv"    , "SystemV", 8,"return (add,.[],(mul,.[],1000));");
+        Chapter21Test.testCPU(src,"arm"      , "SystemV", 5,"return (add,.[],(mul,.[],1000));");
+    }
+
+
+    @Test
+    public void testString() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/stringHash21.smp"));
+        Chapter21Test.testCPU(src,"x86_64_v2", "SystemV", 9,null);
+        Chapter21Test.testCPU(src,"riscv"    , "SystemV", 3,null);
+        Chapter21Test.testCPU(src,"arm"      , "SystemV", 1,null);
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter21Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter21Test.java
new file mode 100644
index 00000000..1bf65cfd
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter21Test.java
@@ -0,0 +1,727 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import com.seaofnodes.simple.util.SB;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter21Test {
+
+    @Test public void testReadBeforeConditionalStore() {
+        var code = new CodeGen("""
+            struct S { int x; }; !S !a=new S; !S !b=new S;
+            a.x=10; b.x=20; !S !p=a; if(arg&1) p=b;
+            int sum=0;
+            for(int i=0; i<6; i++) {
+                sum+=a.x;
+                if(i==2) p.x=30;
+                else if(i==4) b.x=40;
+            }
+            return sum;
+            """).driver(CodeGen.Phase.FinalizeIR);
+        // The i==2 read still sees 10: three reads of 10, then three of 30.
+        assertEquals("120",Eval2.eval(code,0));
+        assertEquals("60",Eval2.eval(code,1));
+    }
+
+
+    @Test public void testArmBitfieldExtracts() {
+        // Independent SXT/UXT instruction words, plus ASR, LSR and LSL aliases.
+        int[] ops = {0x93401c20,0xd3401c20,0x93403c20,0xd3403c20,
+                     0x93407c20,0xd3407c20,0x9344fc20,0xd344fc20,0xd37cec20};
+        long value = 0xa5a5a5a580008080L;
+        long[] expected = {(byte)value,value&255,(short)value,value&65535,
+                           (int)value,value&0xffffffffL,value>>4,value>>>4,value<<4};
+        for( int i=0; i<ops.length; i++ ) {
+            EvalArm64 cpu = new EvalArm64(new byte[1<<16],1<<15);
+            cpu.st4(0,ops[i]); cpu.regs[1]=value;
+            assertEquals(0,cpu.step(1));
+            assertEquals(expected[i],cpu.regs[0]);
+        }
+    }
+
+
+    @Test public void testReturnedFunctionEncoding() throws IOException {
+        String src = "if(arg) return {->42;}; return {->43;};";
+        CodeGen code = new CodeGen(src).driver("riscv","SystemV",null);
+        for( int arg : new int[]{0,1} ) {
+            byte[] image = new byte[1<<16];
+            byte[] bits = code._encoding.bits();
+            System.arraycopy(bits,0,image,0,bits.length);
+            EvalRisc5 cpu = new EvalRisc5(image,1<<15);
+            cpu._pc = code._encoding._opStart[code.link(code._main)._nid];
+            cpu.regs[riscv.A0] = arg;
+            assertEquals(0,cpu.step(100));
+            assertEquals(0,cpu._pc);
+            cpu._pc = (int)cpu.regs[riscv.A0];
+            assertEquals(0,cpu.step(100));
+            assertEquals(0,cpu._pc);
+            assertEquals(arg==0 ? 43 : 42,cpu.regs[riscv.A0]);
+        }
+        // Anonymous bodies need code, but no exported ELF name.
+        new CodeGen(src).driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,"build/objs/anonymous.o");
+    }
+
+    @Test public void testArmFloatMemory() throws IOException {
+        for( String type : new String[]{"f32","f64"} ) {
+            String src = type+"[] !a=new "+type+"[3]; a[arg]=1.25; return a[1];";
+            CodeGen code = new CodeGen(src).driver("arm","SystemV",null);
+            byte[] image = new byte[1<<20];
+            byte[] bits = code._encoding.bits();
+            System.arraycopy(bits,0,image,0,bits.length);
+            EvalArm64 cpu = new EvalArm64(image,1<<16);
+            cpu.regs[arm.X0]=1;
+            assertEquals(0,cpu.step(1000));
+            assertEquals(1.25,cpu.fregs[0],0);
+        }
+        // Independently exercise both SIMD widths and addressing modes. Keep
+        // the GPR value different so accidentally reading that bank is visible.
+        for( boolean wide : new boolean[]{false,true} )
+            for( boolean indexed : new boolean[]{false,true} ) {
+                EvalArm64 cpu = new EvalArm64(new byte[512],256);
+                cpu.regs[1]=128; cpu.regs[2]=16; cpu.regs[3]=99;
+                cpu.fregs[3]=-13.25;
+                int store = (wide ? 0xFD000000 : 0xBD000000) | ((16/(wide?8:4))<<10) | (1<<5) | 3;
+                if( indexed ) store=(wide ? 0xFC226823 : 0xBC226823); // STR D3/S3,[X1,X2]
+                cpu.st4(0,store);
+                cpu.st4(4,store | (1<<22)); // LDR to the same SIMD register.
+                assertEquals(0,cpu.step(1));
+                assertEquals(-13.25,wide ? cpu.ld8f(144) : cpu.ld4f(144),0);
+                cpu.fregs[3]=0;
+                assertEquals(0,cpu.step(1));
+                assertEquals(-13.25,cpu.fregs[3],0);
+            }
+    }
+
+
+    @Test public void testArmCallInstructions() {
+        EvalArm64 cpu = new EvalArm64(new byte[512],256);
+        for( int delta : new int[]{4,32,-4} ) {
+            cpu._pc = 128;
+            for( int i=0; i<32; i++ ) cpu.regs[i]=1000+i;
+            cpu.st4(128,0x94000000 | ((delta>>2)&0x03FFFFFF)); // BL
+            assertEquals(0,cpu.step(1));
+            assertEquals(128+delta,cpu._pc);
+            for( int i=0; i<32; i++ ) assertEquals(i==30 ? 132 : 1000+i,cpu.regs[i]);
+        }
+        for( int rn : new int[]{9,30} )
+            for( boolean call : new boolean[]{false,true} ) {
+                cpu._pc=4;
+                cpu.regs[rn]=64;
+                cpu.st4(4,(call ? 0xD63F0000 : 0xD65F0000) | (rn<<5)); // BLR / RET
+                assertEquals(0,cpu.step(1));
+                assertEquals(64,cpu._pc);
+                if( call ) assertEquals(8,cpu.regs[30]);
+            }
+    }
+
+    @Test public void testArmImmediateArithmetic() {
+        EvalArm64 cpu = new EvalArm64(new byte[16],16);
+        // Unsigned imm12, including bit 11 and the optional 12-bit shift.
+        for( int[] test : new int[][]{{0x91200020,2148},{0xD1200020,-1948},
+                                     {0x91400420,4196},{0xD1400420,-3996}} ) {
+            cpu._pc=0; cpu.regs[1]=100;
+            cpu.N=true; cpu.Z=false; cpu.C=true; cpu.V=true;
+            cpu.st4(0,test[0]);
+            assertEquals(0,cpu.step(1));
+            assertEquals(test[1],cpu.regs[0]);
+            assertTrue(cpu.N); assertFalse(cpu.Z); assertTrue(cpu.C); assertTrue(cpu.V);
+        }
+    }
+
+    @Test public void testArmCallsAndFrames() throws IOException {
+        String src = """
+            val sum = { int n ->
+                if( n<=0 ) return 1;
+                return sum(n-1)+n;
+            };
+            val run = { int n -> return sum(n)+sum(n+1); };
+            """;
+        assertTrue("Ordinary calls must survive optimization",checkArmCalls(src,"run",4,27)>0);
+    }
+
+    @Test public void testArmVectorGrowth() throws IOException {
+        String src = """
+            struct _Vec {
+                u32 !len;
+                int[] !buf;
+                val grow = { int sz ->
+                    var buf2 = new int[sz];
+                    for( int i=0; i<len; i++ ) buf2[i]=buf[i];
+                    buf=buf2;
+                };
+                val add = { int e ->
+                    if( len>=buf# ) grow(buf#*2);
+                    buf[len++]=e;
+                    return self;
+                };
+            };
+            val run = { int arg ->
+                val v = new _Vec{buf=new int[4];}.add(2).add(3).add(5).add(7).add(11);
+                return v.len*100+v.buf[arg];
+            };
+            """;
+        checkArmCalls(src,"run",4,511);
+    }
+
+    private static int checkArmCalls(String src, String entryName, int arg, int result) throws IOException {
+        CodeGen code = new CodeGen(src).driver("arm","SystemV",null);
+        byte[] image = new byte[1<<20];
+        System.arraycopy(code._encoding.bits(),0,image,0,code._encoding.bits().length);
+        EvalArm64 cpu = new EvalArm64(image,1<<16);
+        boolean entry=false;
+        int frames=0, calls=0;
+        for( var bb : code._cfg ) {
+            if( bb instanceof com.seaofnodes.simple.node.FunNode fun ) {
+                int off = code._encoding._opStart[fun._nid];
+                if( entryName.equals(fun._name) ) { cpu._pc=off; entry=true; }
+                int frame=fun._frameAdjust;
+                assertEquals(0,frame&15);
+                if( frame>0 ) {
+                    frames++;
+                    assertEquals(0xD10003FF | (frame<<10),cpu.ld4s(off)); // SUB SP,SP,#bytes
+                }
+            }
+            if( bb instanceof com.seaofnodes.simple.node.ReturnNode ret ) {
+                int off=code._encoding._opStart[ret._nid];
+                int frame=ret.fun()._frameAdjust;
+                if( frame>0 ) {
+                    assertEquals(0x910003FF | (frame<<10),cpu.ld4s(off)); // ADD SP,SP,#bytes
+                    off+=4;
+                }
+                assertEquals(0xD65F03C0,cpu.ld4s(off)); // RET X30
+            }
+            if( bb instanceof com.seaofnodes.simple.node.cpus.arm.CallARM ) calls++;
+        }
+        assertTrue("Must execute the program entry",entry);
+        assertTrue("Exercise stack frames",frames>0);
+        for( int i=19; i<=29; i++ ) cpu.regs[i]=1000+i;
+        cpu.regs[0]=arg;
+        assertEquals(0,cpu.step(10000));
+        assertEquals("Must return to the harness",0,cpu._pc);
+        assertEquals(result,cpu.regs[0]);
+        assertEquals(1<<16,cpu.regs[31]);
+        for( int i=19; i<=29; i++ ) assertEquals(1000+i,cpu.regs[i]);
+        return calls;
+    }
+
+
+    @Test public void testCoalescing() { com.seaofnodes.simple.codegen.RegAllocTestSupport.coalescing(); }
+    @Test public void testCopyForward() throws Exception { com.seaofnodes.simple.codegen.RegAllocTestSupport.copyForward(); }
+
+    @Test public void testNarrowStores() throws IOException {
+        for( String type : new String[]{"i8","u8","i16","u16"} ) {
+            String src = "struct S { "+type+" x; }; !S !s = new S; s.x = arg; return 0;";
+            CodeGen code = new CodeGen(src).driver("riscv","SystemV",null);
+            int stores=0;
+            for( var bb : code._cfg )
+                for( var node : bb.outs() )
+                    if( node instanceof com.seaofnodes.simple.node.cpus.riscv.StoreRISC st ) {
+                        stores++;
+                        assertEquals("Byte/short stores have no FP encoding",-1,st.regmap(4).nextReg((short)31));
+                    }
+            assertEquals(1,stores);
+            byte[] image = new byte[1<<20];
+            byte[] bits = code._encoding.bits();
+            System.arraycopy(bits,0,image,0,bits.length);
+            EvalRisc5 cpu = new EvalRisc5(image,1<<16);
+            cpu.regs[riscv.A0] = 0x8765;
+            assertEquals(0,cpu.step(100));
+            assertEquals(type.endsWith("8") ? 0x65 : 0x8765,
+                         type.endsWith("8") ? cpu.ld1z(1<<16) : cpu.ld2z(1<<16));
+            code = new CodeGen(src).driver(CodeGen.Phase.Encoding,"x86_64_v2",TestC.CALL_CONVENTION);
+            stores=0;
+            for( var bb : code._cfg )
+                for( var node : bb.outs() )
+                    if( node instanceof com.seaofnodes.simple.node.cpus.x86_64_v2.StoreX86 st ) {
+                        stores++;
+                        assertEquals("Byte/short stores have no XMM encoding",-1,st.regmap(4).nextReg((short)15));
+                    }
+            assertEquals(1,stores);
+        }
+    }
+
+    @Test public void testNativeExitStatus() throws IOException {
+        Path source = Path.of("build/objs/nativeExit.c");
+        Files.createDirectories(source.getParent());
+        Files.writeString(source,"int main() { return 7; }\n");
+        try {
+            TestC.gcc(source.toString(),null,null,false,
+                      "build/objs/nativeExit"+(TestC.OS.startsWith("Windows") ? ".exe" : ""));
+        } catch( AssertionError error ) {
+            assertTrue(error.getMessage(),error.getMessage().contains("Program exit status"));
+            return;
+        }
+        fail("A failing native program must fail the test, even with empty stdout");
+    }
+
+    @Test public void testArmSubtractRegisters() {
+        EvalArm64 cpu = new EvalArm64(new byte[16],16);
+        cpu.st4(0,0xCB020020); // SUB X0,X1,X2, no shift or flag update.
+        for( long[] pair : new long[][]{{7,3},{3,7},{Long.MIN_VALUE,1},{1L<<40,3}} ) {
+            cpu._pc = 0;
+            cpu.regs[1] = pair[0]; cpu.regs[2] = pair[1];
+            cpu.N=true; cpu.Z=false; cpu.C=true; cpu.V=true;
+            assertEquals(0,cpu.step(1));
+            assertEquals(pair[0]-pair[1],cpu.regs[0]);
+            assertTrue(cpu.N); assertFalse(cpu.Z); assertTrue(cpu.C); assertTrue(cpu.V);
+        }
+    }
+
+
+    @Test public void testRisc64BitStore() {
+        byte[] mem = new byte[24];
+        EvalRisc5 cpu = new EvalRisc5(mem,mem.length);
+        check64BitStore(mem,cpu::st8,cpu::ld8);
+    }
+
+    @Test public void testArm64BitStore() {
+        byte[] mem = new byte[24];
+        EvalArm64 cpu = new EvalArm64(mem,mem.length);
+        check64BitStore(mem,cpu::st8,cpu::ld8);
+    }
+
+    // Check bytes independently of ld8, including overwrite and adjacent memory.
+    private static void check64BitStore(byte[] mem,
+                                       java.util.function.BiConsumer<Integer,Long> store,
+                                       java.util.function.IntToLongFunction load) {
+        java.util.Arrays.fill(mem,(byte)0xA5);
+        for( long value : new long[]{0x0123456789ABCDEFL,0xFEDCBA9876543210L,
+                                     -1L,0L,Long.MIN_VALUE,Long.MAX_VALUE} ) {
+            store.accept(8,value);
+            for( int i=0; i<mem.length; i++ ) {
+                int expected = i>=8 && i<16 ? (int)(value >>> (8*(i-8)))&0xFF : 0xA5;
+                assertEquals("byte "+i,expected,mem[i]&0xFF);
+            }
+            assertEquals(value,load.applyAsLong(8));
+        }
+    }
+
+
+    // Frozen Jig runs in Chapter23AllocTest; the revised input is in Chapter24AllocTest.
+    @Test @Ignore
+    public void testJig() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp"));
+        testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        testCPU(src,"riscv"    , "SystemV",-1,null);
+        testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+    static void testCPU( String src, String cpu, String os, int spills, String stop ) {
+        CodeGen code = new CheckedCodeGen(src).driver(CodeGen.Phase.Encoding,cpu,os);
+        SpillStats.record(code,"Chapter21",cpu,os);
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+        if( stop != null )
+            assertEquals(stop, code._stop.toString());
+    }
+
+
+    @Test public void testBasic1() {
+        String src = "return arg | 2;";
+        testCPU(src,"x86_64_v2", "SystemV",1,"return (ori,mov(arg));");
+        testCPU(src,"riscv"    , "SystemV",0,"return ( arg | #2 );");
+        testCPU(src,"arm"      , "SystemV",0,"return (ori,arg);");
+    }
+
+    @Test public void testInfinite() {
+        String src = "struct S { int i; }; !S !s = new S; while(1) s.i++;";
+        testCPU(src,"x86_64_v2", "SystemV",0,"return Top;");
+        testCPU(src,"riscv"    , "SystemV",0,"return Top;");
+        testCPU(src,"arm"      , "SystemV",0,"return Top;");
+    }
+
+    @Test
+    public void testArray1() throws IOException {
+        String src =
+"""
+int[] !ary = new int[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<ary#; i++ )
+    ary[i] = i;
+// Fill [0,1,3,6,10,...]
+for( int i=0; i<ary#-1; i++ )
+    ary[i+1] += ary[i];
+return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6
+""";
+        testCPU(src,"x86_64_v2", "SystemV",-1,"return .[];");
+        testCPU(src,"riscv"    , "SystemV", 7,"return (add,.[],(mul,.[],1000));");
+        testCPU(src,"arm"      , "SystemV", 5,"return (add,.[],(mul,.[],1000));");
+    }
+
+    @Test
+    public void testAntiDeps1() throws IOException {
+        String src =
+"""
+struct S { int f; };
+var v0 = new S;
+!S? !v1;
+if (arg) v1 = new S;
+if (v1) {
+    v0.f = v1.f;
+} else {
+    v0.f = 2;
+}
+return v0;
+""";
+        testCPU(src,"x86_64_v2", "SystemV", 7,"return mov(mov(S));");
+        testCPU(src,"riscv"    , "SystemV",10,"return mov(mov(S));");
+        testCPU(src,"arm"      , "SystemV",10,"return mov(mov(S));");
+    }
+
+    @Test
+    public void testString() throws IOException {
+        String src =
+"""
+struct String {
+    u8[] !cs;
+    int _hashCode;
+};
+
+// Compare two Strings
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+// Return the String hashCode (cached, and never 0)
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    for( int i=0; i< self.cs#; i++ )
+        hash = hash*31 + self.cs[i];
+    if( !hash ) hash = 123456789;
+    return hash;
+};
+""";
+        testCPU(src,"x86_64_v2", "SystemV", 9,null);
+        testCPU(src,"riscv"    , "SystemV", 3,null);
+        testCPU(src,"arm"      , "SystemV", 1,null);
+    }
+
+    @Test public void testStringExport() throws IOException {
+        String src =
+"""
+struct String {
+    u8[] !cs;
+    int _hashCode;
+};
+
+// Compare two Strings
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+// Return the String hashCode (cached, and never 0)
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    for( int i=0; i< self.cs#; i++ )
+        hash = hash*31 + self.cs[i];
+    if( !hash ) hash = 123456789;
+    return hash;
+};
+""";
+        TestC.run(src, "stringHash",null, "", 9);
+    }
+
+    @Test public void testLoop2() throws IOException {
+        String src =
+"""
+int i = 0;
+while(true) {
+    i += 1;
+    if( i==0 ) continue;
+    if( i==1 ) continue;
+    if( i==2 ) break;
+    continue;
+}
+return i;
+""";
+        testCPU(src,"x86_64_v2", "Win64"  ,0,"return (inc,Phi(Loop,0,inc));");
+        testCPU(src,"riscv"    , "SystemV",0,"return ( Phi(Loop,0,addi) + #1 );");
+        testCPU(src,"arm"      , "SystemV",0,"return (inc,Phi(Loop,0,inc));");
+    }
+
+    @Test public void testNewtonExport() throws IOException {
+        String result = """
+0  0.000000   (0)
+1  1.000000   (0)
+2  1.414214   (2.22045e-16)
+3  1.732051   (0)
+4  2.000000   (0)
+5  2.236068   (0)
+6  2.449490   (0)
+7  2.645751   (0)
+8  2.828427   (4.44089e-16)
+9  3.000000   (0)
+""";
+        String src =
+"""
+val test_sqrt = { flt x ->
+    flt epsilon = 1e-15;
+    flt guess = x;
+    while( 1 ) {
+        flt next = (x/guess + guess)/2;
+        if( guess-epsilon <= next & next <= guess+epsilon ) return guess;
+        //if( guess==next ) return guess;
+        guess = next;
+    }
+};
+""";
+        TestC.run(src, "newtonFloat", null, result, 34);
+
+        EvalRisc5 R5 = TestRisc5.build("newtonFloat",src, 0, 10, false);
+        R5.fregs[riscv.FA0 - riscv.F_OFFSET] = 3.0;
+        int trap_r5 = R5.step(1000);
+        assertEquals(0,trap_r5);
+        // Return register A0 holds fib(8)==55
+        assertEquals(1.732051,R5.fregs[riscv.FA0 - riscv.F_OFFSET], 0.00001);
+
+        // arm
+        EvalArm64 A5 = TestArm64.build("newtonFloat", src,0, 10, false);
+        A5.fregs[arm.D0 - arm.D_OFFSET] = 3.0;
+        int trap_arm = A5.step(1000);
+        assertEquals(0,trap_arm);
+        assertEquals(1.732051, A5.fregs[arm.D0 - arm.D_OFFSET], 0.00001);
+    }
+
+
+    @Test public void testSieve() throws IOException {
+        String src =
+"""
+val sieve = { int N ->
+    // The main Sieve array
+    bool[] !ary = new bool[N];
+    // The primes less than N
+    u32[] !primes = new u32[N>>1];
+    // Number of primes so far, searching at index p
+    int nprimes = 0, p=2;
+    // Find primes while p^2 < N
+    while( p*p < N ) {
+        // skip marked non-primes
+        while( ary[p] ) p++;
+        // p is now a prime
+        primes[nprimes++] = p;
+        // Mark out the rest non-primes
+        for( int i = p + p; i < ary#; i+= p )
+            ary[i] = true;
+        p++;
+    }
+
+    // Now just collect the remaining primes, no more marking
+    for( ; p < N; p++ )
+        if( !ary[p] )
+            primes[nprimes++] = p;
+
+    // Copy/shrink the result array
+    u32[] !rez = new u32[nprimes];
+    for( int j=0; j < nprimes; j++ )
+        rez[j] = primes[j];
+    return rez;
+};
+""";
+        // The primes
+        int[] primes = new int[]  { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, };
+        SB sb = new SB().p(primes.length).p("[");
+        for( int prime : primes )
+            sb.p(prime).p(", ");
+        String sprimes = sb.p("]").toString();
+
+        // Compile, link against native C; expect the above string of primes to be printed out by C
+        TestC.run(src, "sieve", null, sprimes, 186);
+
+        // Evaluate on RISC5 emulator; expect return of an array of primes in
+        // the simulated heap.
+        EvalRisc5 R5 = TestRisc5.build("sieve", src, 100, 92, false);
+        int trap = R5.step(10000);
+        assertEquals(0,trap);
+        // Return register A0 holds sieve(100)
+        int ary = (int)R5.regs[riscv.A0];
+        // Memory layout starting at ary(length,pad, prime1, primt2, prime3, prime4)
+        assertEquals(primes.length, R5.ld4s(ary));
+        for( int i=0; i<primes.length; i++ )
+            assertEquals(primes[i], R5.ld4s(ary + 4 + i*4));
+
+        // Evaluate on ARM5 emulator; expect return of an array of primes in
+        // the simulated heap.
+        EvalArm64 A5 = TestArm64.build("sieve", src, 100, 94, false);
+        int trap_arm = A5.step(10000);
+        assertEquals(0, trap_arm);
+        int ary_arm = (int)A5.regs[arm.X0];
+        // Memory layout starting at ary(length,pad, prime1, primt2, prime3, prime4)
+        assertEquals(primes.length, A5.ld4s(ary_arm));
+        for( int i = 0; i<primes.length; i++ )
+            assertEquals(primes[i], A5.ld4s(ary_arm + 4 + i * 4));
+    }
+
+    @Test public void testFibExport() throws IOException {
+        String src =
+"""
+val fib = {int n ->
+    int f1=1;
+    int f2=1;
+    while( n-- > 1 ){
+        int temp = f1+f2;
+        f1=f2;
+        f2=temp;
+    }
+    return f2;
+};
+""";
+        String fib = "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]";
+        TestC.run(src, "fib", null, fib, 24);
+
+        EvalRisc5 R5 = TestRisc5.build("fib", src, 9, 17, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        // Return register A0 holds fib(8)==55
+        assertEquals(55,R5.regs[riscv.A0]);
+
+        // arm
+        EvalArm64 A5 = TestArm64.build("fib", src, 9, 17, false);
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+        // Return register X0 holds fib(8)==55
+        assertEquals(55, A5.regs[arm.X0]);
+    }
+
+    @Test public void testPerson() throws IOException {
+        String person = "6\n";
+        TestC.run("person21", person, 0);
+
+        // Memory layout starting at PS:
+        int ps = 1<<16;         // Person array pointer starts at heap start
+        // Person[3] = { len,pad,P0,P1,P2 }; // sizeof = 4*8
+        // P0 = { age } // sizeof=8
+        int p0 = ps+4*8+0*8;
+        // P1 = { age } // sizeof=8
+        int p1 = ps+4*8+1*8;
+        // P2 = { age } // sizeof=8
+        int p2 = ps+4*8+2*8;
+        EvalRisc5 R5 = TestRisc5.build("person21", ps, 0, false);
+        R5.regs[riscv.A1] = 1;  // Index 1
+        R5.st8(ps,3);           // Length
+        R5.st8(ps+1*8,p0);
+        R5.st8(ps+2*8,p1);
+        R5.st8(ps+3*8,p2);
+        R5.st8(p0, 5); // age= 5
+        R5.st8(p1,17); // age=17
+        R5.st8(p2,60); // age=60
+
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals( 5+0,R5.ld8(p0));
+        assertEquals(17+1,R5.ld8(p1));
+        assertEquals(60+0,R5.ld8(p2));
+
+        EvalArm64 A5 = TestArm64.build("person21", ps, 0, false);
+        A5.regs[arm.X1] = 1;  // Index 1
+        A5.st8(ps, 3);
+        A5.st8(ps+1*8,p0);
+        A5.st8(ps+2*8,p1);
+        A5.st8(ps+3*8,p2);
+        A5.st8(p0, 5); // age= 5
+        A5.st8(p1,17); // age=17
+        A5.st8(p2,60); // age=60
+
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+        assertEquals( 5+0, A5.ld8(p0));
+        assertEquals(17+1, A5.ld8(p1));
+        assertEquals(60+0, A5.ld8(p2));
+    }
+
+    @Test public void testArgCount() throws IOException {
+        // Test passes more args than registers in Sys5, which is far far more
+        // than what Win64 allows - so Win64 gets a lot more spills here.
+        String arg_count = "191.000000\n";
+        TestC.run("arg_count", arg_count,
+                  TestC.CALL_CONVENTION.equals("Win64") ? 32 : 9);
+
+
+        EvalRisc5 R5 = TestRisc5.build("no_stack_arg_count", 0, 0, false);
+
+        // Todo: handle stack(imaginary stack in emulator)
+        // pass in float arguments
+        R5.fregs[riscv.FA0 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA1 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA2 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA3 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA4 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA5 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA6 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA7 - riscv.F_OFFSET] = 1.1;
+
+        // a0 is passed in arg
+        R5.regs[riscv.A1] = 2;
+        R5.regs[riscv.A2] = 2;
+        R5.regs[riscv.A3] = 2;
+        R5.regs[riscv.A4] = 2;
+        R5.regs[riscv.A5] = 2;
+        R5.regs[riscv.A6] = 2;
+        R5.regs[riscv.A7] = 2;
+
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+
+        double result = R5.fregs[riscv.FA0 - riscv.F_OFFSET];
+
+        assertEquals(22.8, result, 0.00001);
+
+        // arm
+        EvalArm64 A5 = TestArm64.build("no_stack_arg_count", 0, 0, false);
+
+        A5.fregs[arm.D0 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D1 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D2 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D3 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D4 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D5 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D6 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D7 - arm.D_OFFSET] = 1.1;
+
+        A5.regs[arm.X1]  = 2;
+        A5.regs[arm.X2]  = 2;
+        A5.regs[arm.X3]  = 2;
+        A5.regs[arm.X4]  = 2;
+        A5.regs[arm.X5]  = 2;
+        A5.regs[arm.X6]  = 2;
+        A5.regs[arm.X7]  = 2;
+
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+
+        double result1 = A5.fregs[arm.D0 - arm.D_OFFSET];
+        assertEquals(22.8, result1, 0.00001);
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter22Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter22Test.java
new file mode 100644
index 00000000..3ff8dc09
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter22Test.java
@@ -0,0 +1,432 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter22Test {
+
+    @Test public void testNarrowCReturnsEmulated() {
+        String[] types = {"i8","u8","i16","u16","i32","u32","int"};
+        long[] values = {0xa5a5a5a500000000L,0xa5a5a5a50000007fL,0xa5a5a5a500000080L,
+            0xa5a5a5a500007fffL,0xa5a5a5a500008000L,0xa5a5a5a57fffffffL,
+            0xa5a5a5a580000000L,0xa5a5a5a5ffffffffL};
+        for( String target : new String[]{"arm","riscv"} )
+            for( int i=0; i<types.length; i++ ) {
+                String src = "{"+types[i]+"} c_narrow=\"C\"; return c_narrow();";
+                CodeGen code = new CheckedCodeGen(src).driver(CodeGen.Phase.Encoding,target,"SystemV");
+                var enc = code._encoding;
+                // Link the external call to a tiny independent native stub.
+                var call = code._stop.walk(n -> n instanceof com.seaofnodes.simple.node.CallNode ? n : null);
+                int start = enc._opStart[call._nid];
+                ((com.seaofnodes.simple.codegen.RIPRelSize)call).patch(enc,start,enc._opLen[call._nid],0x1000-start);
+                for( long value : values ) {
+                    long expected = switch(i) {
+                    case 0 -> (byte)value; case 1 -> value&255;
+                    case 2 -> (short)value; case 3 -> value&65535;
+                    case 4 -> (int)value; case 5 -> value&0xffffffffL;
+                    default -> value;
+                    };
+                    byte[] image = new byte[1<<16];
+                    byte[] bits = enc.bits();
+                    System.arraycopy(bits,0,image,0,bits.length);
+                    if( target.equals("arm") ) {
+                        EvalArm64 cpu = new EvalArm64(image,1<<15);
+                        // MOVZ X0,0x1100; LDR X0,[X0]; RET X30.
+                        cpu._pc = enc._opStart[code.link(code._main)._nid];
+                        cpu.st4(0x1000,0xd2822000); cpu.st4(0x1004,0xf9400000);
+                        cpu.st4(0x1008,0xd65f03c0);
+                        cpu.st8(0x1100,value);
+                        assertEquals(0,cpu.step(1000));
+                        assertEquals(0,cpu._pc);
+                        assertEquals(types[i],expected,cpu.regs[0]);
+                    } else {
+                        EvalRisc5 cpu = new EvalRisc5(image,1<<15);
+                        // AUIPC a0,0; LD a0,12(a0); RET.
+                        cpu._pc = enc._opStart[code.link(code._main)._nid];
+                        cpu.st4(0x1000,0x00000517); cpu.st4(0x1004,0x00c53503);
+                        cpu.st4(0x1008,0x00008067);
+                        // RV64 widens even u32 returns by sign-extending bit 31.
+                        cpu.st8(0x100c,i==6 ? value : (int)expected);
+                        assertEquals(0,cpu.step(1000));
+                        assertEquals(0,cpu._pc);
+                        assertEquals(types[i],expected,cpu.regs[riscv.A0]);
+                    }
+                }
+            }
+    }
+
+    @Test public void testNarrowCReturns() throws IOException {
+        String src = """
+            {i8} c_i8="C"; {u8} c_u8="C";
+            {i16} c_i16="C"; {u16} c_u16="C";
+            {i32} c_i32="C"; {u32} c_u32="C";
+            {int} c_i64="C";
+            val test_i8={->return c_i8();};
+            val test_u8={->return c_u8();};
+            val test_i16={->return c_i16();};
+            val test_u16={->return c_u16();};
+            val test_i32={->return c_i32();};
+            val test_u32={->return c_u32();};
+            val test_i64={->return c_i64();};
+            val test_cmp={->return c_i32()==-1;};
+            """;
+        for( String conv : new String[]{"SystemV","Win64"} )
+            TestC.run(src,conv,com.seaofnodes.simple.type.TypeInteger.BOT,conv.equals("SystemV") ? "sysv_abi" : "ms_abi",
+                      "src/test/java/com/seaofnodes/simple/progs/c_returns.c",
+                      "build/objs/c_returns"+conv,"S","",-1);
+    }
+
+
+
+    @Test public void testReturnedFunctions() throws IOException {
+        for( String src : new String[]{"return {->42;};", "val f={->42;}; return f;", "return sys.io.p;"} )
+            for( String target : new String[]{"riscv","arm"} ) {
+                CodeGen code = new CheckedCodeGen(src).driver(CodeGen.Phase.Encoding,target,"SystemV").exportELF(null);
+                byte[] image = new byte[1<<16];
+                byte[] bits = code._encoding.bits();
+                System.arraycopy(bits,0,image,0,bits.length);
+                boolean library = src.contains("sys.io.p");
+                // u8[]: four-byte length followed by its bytes.
+                image[0x2000]=2; image[0x2004]='o'; image[0x2005]='k';
+                int entry = code._encoding._opStart[code.link(code._main)._nid];
+                if( target.equals("riscv") ) {
+                    EvalRisc5 cpu = new EvalRisc5(image,1<<15);
+                    cpu._pc = entry;
+                    assertEquals(0,cpu.step(1000));
+                    assertEquals(0,cpu._pc);
+                    cpu._pc = (int)cpu.regs[riscv.A0]; // Call the returned address.
+                    cpu.regs[library ? riscv.A1 : riscv.A0] = 0x2000; // Methods also receive self.
+                    assertEquals(0,cpu.step(1000));
+                    assertEquals(0,cpu._pc);
+                    if( library ) assertEquals("ok",cpu._stdout.toString());
+                    else assertEquals(42,cpu.regs[riscv.A0]);
+                } else {
+                    EvalArm64 cpu = new EvalArm64(image,1<<15);
+                    cpu._pc = entry;
+                    assertEquals(0,cpu.step(1000));
+                    assertEquals(0,cpu._pc);
+                    cpu._pc = (int)cpu.regs[0];
+                    cpu.regs[library ? 1 : 0] = 0x2000;
+                    assertEquals(0,cpu.step(1000));
+                    assertEquals(0,cpu._pc);
+                    if( library ) assertEquals("ok",cpu._stdout.toString());
+                    else assertEquals(42,cpu.regs[0]);
+                }
+            }
+        CodeGen unused = new CodeGen("({->42;}); return 0;").driver(CodeGen.Phase.FinalizeIR);
+        assertEquals(1,unused._stop.nIns());
+    }
+
+    @Test public void testReturnedFunctionsNative() throws IOException {
+        String src = "val factory={int x -> if(x) return {->42;}; return {->43;};}; val printer={->return sys.io.p;};";
+        String obj = "build/objs/funptr.o";
+        new CheckedCodeGen(src).driver(TestC.CPU_PORT,TestC.CALL_CONVENTION,obj);
+        assertEquals("ok",TestC.gcc(obj,"","src/test/java/com/seaofnodes/simple/progs/funptr.c",false,
+                                   "build/objs/funptr"+(TestC.OS.startsWith("Windows") ? ".exe" : "")));
+    }
+
+
+    @Test public void testRiscvRightShifts() {
+        // SRAI, SRLI, SRA, SRL: a0 = -32 shifted by 4.
+        int[] ops = {0x40455513,0x00455513,0x40b55533,0x00b55533};
+        for( int i=0; i<ops.length; i++ ) {
+            EvalRisc5 r5 = new EvalRisc5(new byte[1<<16],1<<15);
+            r5.st4(0,ops[i]);
+            r5.regs[riscv.A0] = -32;
+            r5.regs[riscv.A0+1] = 4;
+            assertEquals(0,r5.step(1));
+            assertEquals((i&1)==0 ? -2L : 0x0fff_ffff_ffff_fffeL,r5.regs[riscv.A0]);
+        }
+    }
+
+    @Test public void testRiscvPointerRelocation() {
+        CodeGen code = new CheckedCodeGen("return \"x\";").driver(CodeGen.Phase.Encoding,"riscv","SystemV");
+        var enc = code._encoding;
+        assertEquals(1,enc._bigCons.size());
+        var ptr = (com.seaofnodes.simple.node.cpus.riscv.TMPRISC)enc._bigCons.keySet().iterator().next();
+        int start = enc._opStart[ptr._nid];
+        for( int delta : new int[]{0x7ff,0x800,0xfff,0x1000,0x1800,-1,-0x800,-0x801} ) {
+            ptr.patch(enc,start,enc._opLen[ptr._nid],delta);
+            // Place the program above zero so backward targets are valid addresses.
+            byte[] image = new byte[1<<16];
+            System.arraycopy(enc.bits(),0,image,0x4000,enc._bits.size());
+            EvalRisc5 r5 = new EvalRisc5(image,1<<15);
+            r5._pc = 0x4000;
+            assertEquals(0,r5.step(100));
+            assertEquals(0x4000+start+delta,r5.regs[riscv.A0]);
+        }
+    }
+
+    @Test public void testSubZeroTypeError() {
+        try {
+            new CodeGen("return null-0;").driver(CodeGen.Phase.TypeCheck);
+            fail("Subtraction must reject null even when the other operand is zero");
+        } catch( Parser.ParseException e ) {
+            assertEquals("Cannot '-' null",e.getMessage());
+        }
+    }
+
+    @Test public void testInfiniteReturn() {
+        String src = "struct S { int i; }; !S !s = new S; while(1) s.i++; return s.i;";
+        testCPU(src,"x86_64_v2","SystemV",0,"return Top;");
+        testCPU(src,"riscv","SystemV",0,"return Top;");
+        testCPU(src,"arm","SystemV",0,"return Top;");
+    }
+
+
+    // Frozen Jig runs in Chapter23AllocTest; the revised input is in Chapter24AllocTest.
+    @Test @Ignore
+    public void testJig() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp"));
+        //String src = Files.readString(Path.of("docs/examples/BubbleSort.smp"));
+        testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        testCPU(src,"riscv"    , "SystemV",-1,null);
+        testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+    static CodeGen testCPU( String src, String cpu, String os, int spills, String stop ) {
+        CodeGen code = new CheckedCodeGen(src).driver(CodeGen.Phase.Encoding,cpu,os);
+        SpillStats.record(code,"Chapter22",cpu,os);
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+        if( stop != null )
+            assertEquals(stop, code._stop.toString());
+        return code;
+    }
+
+
+    static int testCPUSize( String src, String cpu, String os, int spills, String stop ) {
+        return testCPU(src,cpu,os,spills,stop)._encoding._bits.size();
+    }
+
+    // Should not fold away
+    @Test public void testSextFail() throws IOException {
+        String src = """
+struct Person { i32 age;};
+!Person !p = new Person;
+p.age = (arg<<17)>>17;
+return 0;
+""";
+        assertEquals(46, testCPUSize(src, "x86_64_v2","Win64",2,"return 0;"));
+        assertEquals(60, testCPUSize(src, "riscv","SystemV",4,"return 0;"));
+        assertEquals(56, testCPUSize(src, "arm","SystemV",4,"return 0;"));
+
+        // do assertEquals here
+        EvalRisc5 R5 = TestRisc5.build("sext_str_not_fold_away", src,0, 4, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+
+        EvalArm64 A5 = TestArm64.build("sext_str_not_fold_away", src, 0, 4, false);
+        trap = A5.step(100);
+        assertEquals(0,trap);
+
+    }
+
+    // Should not fold away
+    @Test public void testSextFail2() throws IOException {
+        String src = """
+
+                struct Person { i32 age;};
+                !Person !p = new Person;
+                p.age = (arg<<48)>>48;
+                return 0;
+        """;
+
+        EvalRisc5 R5 = TestRisc5.build("sext_str_not_fold_away_2", src, 0, 4, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+
+        EvalArm64 A5 = TestArm64.build("sext_str_not_fold_away_2", src, 0, 4, false);
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+
+        assertEquals(46, testCPUSize(src, "x86_64_v2","Win64",2,"return 0;"));
+        assertEquals(60, testCPUSize(src, "riscv","SystemV",4,"return 0;"));
+        assertEquals(56, testCPUSize(src, "arm","SystemV",4,"return 0;"));
+
+    }
+
+    // Should fold away
+    @Test public void testSextSuccess() throws IOException {
+        String src = """
+// Should fold away sign extend
+struct Person { i8 age;};
+!Person !p = new Person;
+p.age = (arg<<48)>>48;
+return 0;
+       """;
+
+        EvalRisc5 R5 = TestRisc5.build("sext_str_fold_away", src, 0, 5, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+
+        EvalArm64 A5 = TestArm64.build("sext_str_fold_away", src, 0, 5, false);
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+
+        assertEquals(41, testCPUSize(src, "x86_64_v2","Win64",2,"return 0;"));
+        assertEquals(56, testCPUSize(src, "riscv","SystemV",5,"return 0;"));
+        assertEquals(52, testCPUSize(src, "arm","SystemV",5,"return 0;"));
+        // do assertEquals here
+    }
+
+
+    // Int now is changed to 4 bytes.
+    @Test public void testPerson() throws IOException {
+        String src =
+"""
+struct Person {
+    i32 age;
+};
+
+val fcn = { !Person?[] !ps, int x ->
+    if( ps[x] )
+        ps[x].age++;
+};
+""";
+        String person = "6\n";
+        TestC.run(src, "person", null, person, 0);
+
+        // Memory layout starting at PS:
+        int ps = 1<<16;         // Person array pointer starts at heap start
+        // Person[3] = { len,pad,P0,P1,P2 }; // sizeof = 4*8
+        // P0 = { age } // sizeof=8
+        int p0 = ps+4*8+0*8;
+        // P1 = { age } // sizeof=8
+        int p1 = ps+4*8+1*8;
+        // P2 = { age } // sizeof=8
+        int p2 = ps+4*8+2*8;
+        EvalRisc5 R5 = TestRisc5.build("person", src, ps, 0, false);
+        R5.regs[riscv.A1] = 1;  // Index 1
+        R5.st8(ps,3);           // Length
+        R5.st8(ps+1*8,p0);
+        R5.st8(ps+2*8,p1);
+        R5.st8(ps+3*8,p2);
+        R5.st8(p0, 5); // age= 5
+        R5.st8(p1,17); // age=17
+        R5.st8(p2,60); // age=60
+
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals( 5+0,R5.ld8(p0));
+        assertEquals(17+1,R5.ld8(p1));
+        assertEquals(60+0,R5.ld8(p2));
+
+        EvalArm64 A5 = TestArm64.build("person", src, ps, 0, false);
+        A5.regs[arm.X1] = 1;  // Index 1
+        A5.st8(ps, 3);
+        A5.st8(ps+1*8,p0);
+        A5.st8(ps+2*8,p1);
+        A5.st8(ps+3*8,p2);
+        A5.st8(p0, 5); // age= 5
+        A5.st8(p1,17); // age=17
+        A5.st8(p2,60); // age=60
+
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+        assertEquals( 5+0, A5.ld8(p0));
+        assertEquals(17+1, A5.ld8(p1));
+        assertEquals(60+0, A5.ld8(p2));
+    }
+
+    @Test
+    public void testCoRecur() {
+        String src = """
+struct A { !B? !b; !C? !c; i64 ax; val az = x*2; };
+struct B { !A? !a; !C? !c; f32 bx; val bz = x*3; };
+struct C { !A? !a; !B? !b; f64 cx; val cz = x*x; };
+!A !aa = new A{ ax=17; };
+!B !bb = new B{ bx=3.14; a = aa; };
+!C !cc = new C{ cx=2.73; a = aa; b = bb; };
+aa.b = bb;
+aa.c = cc;
+bb.c = cc;
+val x = 5; // aa.az; // Error to self-define forward ref
+return cc.cz;
+""";
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 25;", code._stop.toString());
+        assertEquals("25", Eval2.eval(code, 0));
+    }
+
+    @Test
+    public void testHelloWorld() throws IOException {
+        String src =
+"""
+sys.io.p("Hello, World!");
+return 0;
+""";
+        TestC.run(src,TestC.CALL_CONVENTION,null, null,null,"build/objs/helloWorld","","Hello, World!",0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("helloWorld", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Hello, World!",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("helloWorld", src,0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Hello, World!",arm._stdout.toString());
+    }
+
+    @Test
+    public void testFinalArray() {
+        String src = """
+int N=4;
+i32[] !is = new i32[N];
+for( int i=0; i<N; i++ )
+    is[i] = i*i;
+val sum = { i32[~] is ->  // final array
+    int sum=0;
+    for( int i=0; i<is#; i++ )
+        sum += is[i];
+    return sum;
+};
+return sum(is);
+""";
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return Phi(Loop,0,(Phi_sum+.[]));", code._stop.toString());
+        assertEquals("14", Eval2.eval(code, 0));
+    }
+
+
+    @Test @Ignore
+    public void testEcho() throws IOException {
+        String src =
+"""
+// Echo stdin to stdout.
+return sys.io.p( sys.io.stdin() );
+""";
+        TestC.run(src,TestC.CALL_CONVENTION,null, null,null,"build/objs/echo","","",0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("echo", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("echo", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+    }
+
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter23AllocTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter23AllocTest.java
new file mode 100644
index 00000000..f3cc7512
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter23AllocTest.java
@@ -0,0 +1,37 @@
+package com.seaofnodes.simple;
+
+import java.io.IOException;
+import java.nio.file.*;
+import org.junit.Ignore;
+import org.junit.Test;
+
+// Revised or newly enabled allocation examples in Chapter 23.
+public class Chapter23AllocTest {
+    @Test
+    public void testString() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/stringHash.smp"));
+        Chapter23Test.testCPU(src,"x86_64_v2", "SystemV", 9,null);
+        Chapter23Test.testCPU(src,"riscv"    , "SystemV", 3,null);
+        Chapter23Test.testCPU(src,"arm"      , "SystemV", 1,null);
+    }
+
+    @Ignore
+    @Test
+    public void testJig21() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp"));
+        Chapter23Test.testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        Chapter23Test.testCPU(src,"riscv"    , "SystemV",-1,null);
+        Chapter23Test.testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+    @Ignore
+    @Test
+    public void testJig22() throws IOException {
+        String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp"));
+        //String src = Files.readString(Path.of("docs/examples/BubbleSort.smp"));
+        Chapter23Test.testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        Chapter23Test.testCPU(src,"riscv"    , "SystemV",-1,null);
+        Chapter23Test.testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter23Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter23Test.java
new file mode 100644
index 00000000..22be3af1
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter23Test.java
@@ -0,0 +1,422 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import com.seaofnodes.simple.type.TypeInteger;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter23Test {
+    @Test public void testPopularUses() { com.seaofnodes.simple.codegen.RegAllocTestSupport.popularUses(); }
+
+    @Test public void testDiagnosticTypeAccessors() throws Exception {
+        new CodeGen("return 0;").parse();
+        var tfp = TypeFunPtr.TEST;
+        var con = new ConstantNode(tfp);
+        var call = new CallNode(null,con,con,con);
+        var field = Type.class.getDeclaredField("VISIT");
+        field.setAccessible(true);
+        var visit = (java.util.Map<Object,Type>)field.get(null);
+        var marker = new Object();
+        visit.put(marker,Type.BOTTOM);
+        try {
+            assertEquals(0,TypeInteger.ZERO.alignment());
+            assertEquals(0,TypeInteger.ZERO.value());
+            org.junit.Assert.assertTrue(tfp._isConstant());
+            con.toString();
+            call.name();
+            con.p(1);
+            org.junit.Assert.assertSame(Type.BOTTOM,visit.get(marker));
+            assertEquals(1,visit.size());
+        } finally { visit.clear(); }
+    }
+
+
+    @Test
+    public void testOrRhsLoopLocal() throws IOException {
+        checkOrRhsLoop("""
+            struct S { int f; };
+            int x = 0;
+            int result = (arg & 1) || (new S {
+                while (x < 3) x++;
+                f = ++x;
+            }).f;
+            return x * 10 + result;
+            """);
+    }
+
+    @Test
+    public void testOrRhsLoopMemory() throws IOException {
+        checkOrRhsLoop("""
+            struct S { int f; };
+            !S !s = new S;
+            int result = (arg & 1) || (new S {
+                while (s.f < 3) s.f++;
+                s.f++;
+                f = s.f;
+            }).f;
+            return s.f * 10 + result;
+            """);
+    }
+
+    private static void checkOrRhsLoop(String src) throws IOException {
+        CodeGen code = new CheckedCodeGen(src).driver("riscv", "SystemV", null);
+        SpillStats.record(code,"Chapter23","riscv","SystemV");
+        for (int arg : new int[]{0, 1, 2, 3}) {
+            byte[] image = new byte[1 << 20];
+            System.arraycopy(code._encoding.bits(), 0, image, 0, code._encoding._bits.size());
+            EvalRisc5 r5 = new EvalRisc5(image, 1 << 16);
+            r5.regs[riscv.A0] = arg;
+            assertEquals("Execution must finish", 0, r5.step(1000));
+            // False LHS runs the loop and final increment, returning 4.
+            // True LHS skips all RHS effects and returns the LHS value, 1.
+            assertEquals("OR result and side effects for arg=" + arg,
+                (arg & 1) == 0 ? 44 : 1, r5.regs[riscv.A0]);
+        }
+    }
+
+    @Ignore
+    @Test
+    public void testJig() throws IOException {
+        String src =
+"""
+var apply = { i64 x, { i64 -> u32 } fcn ->
+    return fcn(x);
+}
+""";
+    }
+
+
+    static CodeGen testCPU( String src, String cpu, String os, int spills, String stop ) {
+        CodeGen code = new CheckedCodeGen(src).driver(CodeGen.Phase.Encoding,cpu,os);
+        SpillStats.record(code,"Chapter23",cpu,os);
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+        if( stop != null )
+            assertEquals(stop, code._stop.toString());
+        return code;
+    }
+
+    @Test
+    public void testOr() throws IOException {
+        String src =
+                """
+                int a = 1;
+                int b = 0;
+                
+                if(a++ || b++ ) {
+                    if(b == 0 && a == 2) {
+                        sys.io.p("Or");
+                    }
+                } else{
+                    sys.io.p("And");
+                }
+                return 0;
+                """;
+
+        TestC.runSF("or1", src, null, "Or", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("or1", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Or",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("or1", src,0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Or",arm._stdout.toString());
+    }
+
+    @Test
+    public void testAnd() throws IOException {
+        String src =
+                """
+                int a = 1;
+                int b = 1;
+                
+                if(a && b) {
+                    sys.io.p("And");
+                } else {
+                    sys.io.p("Or");
+                }
+                return 0;
+                """;
+        TestC.runSF("and1", src, null, "And", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("and1", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("And",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("and1", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("And",arm._stdout.toString());
+    }
+
+    @Test
+    public void testAndPtr() throws IOException {
+        // Todo: have one src here
+        String src =
+                """
+                struct S { !S? !fld; };
+                val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};};
+                return ptr && ptr.fld ? "true" : "false";
+                """;
+        String src2 =
+                """
+                struct S { !S? !fld; };
+                
+                val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};};
+                if( ptr && ptr.fld ) {
+                  sys.io.p("true");
+                } else {
+                  sys.io.p("false");
+                }
+                
+                return 0;
+                """;
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("[97-117][ 116,114,117,101]", Eval2.eval(code, 0));
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("ptrand",src2, 1, 8, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("false",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("ptrand", src2, 1, 8, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("false",arm._stdout.toString());
+    }
+
+    // conditional side effect
+    @Test
+    public void testCondSideEffAnd() throws IOException {
+        String src =
+                """
+                int a = 1;
+                int b = 1;
+                
+                int x=1;
+                int y=1;
+                int z=0;
+                
+                int g = x++ && y++ && z++;
+                
+                if(x == 2 && y == 2 && z == 1 && g == 0) {
+                    sys.io.p("Effected");
+                } else {
+                    sys.io.p("Not effected");
+                }
+                return 0;
+                """;
+
+        TestC.runSF("and2", src, null, "Effected", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("and2", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Effected",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("and2", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Effected",arm._stdout.toString());
+    }
+
+    @Test
+    public void testCondSideEffOr() throws IOException {
+        String src =
+                """
+                int a = 1;
+                int b = 1;
+                
+                int x = -1;
+                int y=1;
+                int z= -1;
+                
+                int g = x++ || y++ || z++;
+                
+                int switch = 0;
+                if(x == 4 || y == 4 || z == 4) {
+                    switch = -1;
+                } else {
+                    switch = 1;
+                }
+                int cd = 1;
+                if((x == 0 && y == 1 && z==-1) && switch && g) {
+                    sys.io.p("Effected");
+                } else {
+                    sys.io.p("Not effected");
+                }
+                return 0;
+                """;
+        TestC.runSF("or2", src, null, "Effected", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("or2", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Effected",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("or2", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Effected",arm._stdout.toString());
+    }
+
+    // test it with function calls
+    @Test
+    public void testFuncCall() throws IOException {
+        String src =
+                """
+                // -*- mode: java;  -*-
+                int a = 1;
+                int b = 1;
+                
+                var sq = { int x ->
+                    x*x;
+                };
+                
+                if(a && sq(0)) {
+                    sys.io.p("And");
+                } else {
+                    sys.io.p("Or");
+                }
+                return 0;
+                """;
+        TestC.runSF("and3", src, null, "Or", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("and3", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Or",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("and3", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Or",arm._stdout.toString());
+    }
+
+
+    @Test
+    public void testFRefFields() {
+        String src =
+"""
+// A hypothetical scanner class
+struct Scan {
+    int !x;
+    u8[~] !buf;
+    // Skip whitespace
+    val skip = { !Scan s ->
+        while( s.buf[s.x] <= ' ' )
+            s.x++;
+    };
+    // Peek a character; if matched consume it, else false.
+    val peek = { !Scan !s, u8 c ->
+        skip(s);
+        if( s.buf[s.x] != c ) return false;
+        s.x++;
+        return true;
+    };
+};
+!Scan !s = new Scan{ buf = "  q"; };
+return Scan.peek(s,'q');
+        """;
+
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return Phi(Region,0,1);", code._stop.toString());
+        assertEquals("1", Eval2.eval(code, 0));
+        testCPU(src,"x86_64_v2", "Win64"  ,23,null);
+    };
+
+    @Test
+    public void testFRefFields2() {
+        String src =
+"""
+// A hypothetical scanner class
+struct Scan {
+    int !x;
+    u8[~] !buf;
+    // Skip whitespace
+    val skip = { ->
+        while( buf[x] <= ' ' )
+            x++;
+        return self;
+    };
+};
+~Scan s = new Scan{ buf = "  q"; };
+return s.skip().x;
+        """;
+
+        try { new CodeGen(src).driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { org.junit.Assert.assertTrue(e.getMessage().startsWith("Argument #0 isa")); }
+    };
+
+
+    @Test
+    public void testMethod() {
+        String src =
+"""
+// A hypothetical scanner class
+struct Scan {
+    int !x;
+    u8[~] !buf;
+    // Skip whitespace
+    val skip = { ->
+        while( buf[x] <= ' ' )
+            x++;
+    };
+    val require = { u8 ch ->
+        skip();
+        buf[x++]==ch;
+    };
+};
+!Scan !s = new Scan{ buf = "  [1,2]"; };
+return s.require('[');
+        """;
+
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return (.[]==91);", code._stop.toString());
+        assertEquals("1", Eval2.eval(code, 0));
+        testCPU(src,"x86_64_v2", "Win64"  ,4,null);
+    };
+
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter24AllocTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter24AllocTest.java
new file mode 100644
index 00000000..7fae2c27
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter24AllocTest.java
@@ -0,0 +1,170 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import java.io.IOException;
+import java.nio.file.*;
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+// Revised inherited programs belong to the chapter which changed their inputs.
+public class Chapter24AllocTest {
+    @Test
+    public void testNewtonInteger() {
+        String src =
+"""
+// Newtons approximation to the square root
+val sqrt = { int x ->
+    int guess = x;
+    while( 1 ) {
+        int next = (x/guess + guess)/2;
+        if( next == guess ) return guess;
+        guess = next;
+    }
+};
+int cast_int = arg+2;
+return sqrt(arg) + sqrt(cast_int);
+""";
+        Chapter24Test.testCPU(src,"x86_64_v2", "Win64"  ,40,null);
+        Chapter24Test.testCPU(src,"riscv"    , "SystemV",19,null);
+        Chapter24Test.testCPU(src,"arm"      , "SystemV",19,null);
+    }
+
+    @Ignore
+    @Test
+    public void testJig21() throws IOException {
+        String src =
+"""
+struct s0 {
+    bool v1;
+    i16 v2;
+    int v3;
+    i8 v4;
+    byte v5;
+};
+while(new s0.v3)
+    while(new s0.v5<<new s0.v4) {}
+if(0) {
+    if(0) {
+        flt !P5ZUD4=new s0.v2;
+    }
+    while(0) {}
+}
+return new s0.v1;
+""";
+        Chapter24Test.testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        Chapter24Test.testCPU(src,"riscv"    , "SystemV",-1,null);
+        Chapter24Test.testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+    @Test public void testStackArguments() throws IOException {
+        // Test passes more args than registers in Sys5, which is far far more
+        // than what Win64 allows - so Win64 gets a lot more spills here.
+        String src =
+"""
+val addAll = { int i0, flt f1, int i2, flt f3, int i4, flt f5, int i6, flt f7, int x8, flt f9, int i10, flt f11, int i12, flt f13, int i14, flt f15, int x16, flt f17 int x18, flt f19 ->
+    return
+    i0 + f1+ i2+ f3+ i4+ f5+ i6+ f7+ x8 +f9 +
+    i10+f11+i12+f13+i14+f15+x16+f17+x18+f19 ;
+};
+""";
+        String arg_count = "191.000000\n";
+
+        TestC.run(src, "arg_count", null, arg_count, TestC.CALL_CONVENTION.equals("Win64") ? 32 : 9);
+
+        EvalRisc5 R5 = TestRisc5.build("no_stack_arg_count", src, 0, 4, false);
+
+        // Todo: handle stack(imaginary stack in emulator)
+        // pass in float arguments
+        R5.fregs[riscv.FA0 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA1 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA2 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA3 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA4 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA5 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA6 - riscv.F_OFFSET] = 1.1;
+        R5.fregs[riscv.FA7 - riscv.F_OFFSET] = 1.1;
+
+        // a0 is passed in arg
+        R5.regs[riscv.A1] = 2;
+        R5.regs[riscv.A2] = 2;
+        R5.regs[riscv.A3] = 2;
+        R5.regs[riscv.A4] = 2;
+        R5.regs[riscv.A5] = 2;
+        R5.regs[riscv.A6] = 2;
+        R5.regs[riscv.A7] = 2;
+
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+
+        double result = R5.fregs[riscv.FA0 - riscv.F_OFFSET];
+
+        assertEquals(22.8, result, 0.00001);
+
+        // arm
+        EvalArm64 A5 = TestArm64.build("no_stack_arg_count", src, 0, 4, false);
+
+        A5.fregs[arm.D0 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D1 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D2 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D3 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D4 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D5 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D6 - arm.D_OFFSET] = 1.1;
+        A5.fregs[arm.D7 - arm.D_OFFSET] = 1.1;
+
+        A5.regs[arm.X1]  = 2;
+        A5.regs[arm.X2]  = 2;
+        A5.regs[arm.X3]  = 2;
+        A5.regs[arm.X4]  = 2;
+        A5.regs[arm.X5]  = 2;
+        A5.regs[arm.X6]  = 2;
+        A5.regs[arm.X7]  = 2;
+
+        int trap_arm = A5.step(100);
+        assertEquals(0,trap_arm);
+
+        double result1 = A5.fregs[arm.D0 - arm.D_OFFSET];
+        assertEquals(22.8, result1, 0.00001);
+    }
+
+    @Ignore
+    @Test
+    public void testJig22() throws IOException {
+        String src =
+"""
+val fib = {int n ->
+    int temp=0;
+    int f1=1;
+    int f2=1;
+    int i=n;
+    while( i>1 ){
+        temp = f1+f2;
+        f1=f2;
+        f2=temp;
+        i=i-1;
+    }
+    return f2;
+};
+
+fib(10);
+""";
+        Chapter24Test.testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        Chapter24Test.testCPU(src,"riscv"    , "SystemV",-1,null);
+        Chapter24Test.testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+    @Test
+    public void testBubbleSort() throws IOException {
+        //String src = Files.readString(Path.of("src/test/java/com/seaofnodes/simple/progs/jig.smp"));
+        String src = Files.readString(Path.of("docs/examples/BubbleSort.smp"));
+        Chapter24Test.testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        Chapter24Test.testCPU(src,"riscv"    , "SystemV",-1,null);
+        Chapter24Test.testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter24Test.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter24Test.java
new file mode 100644
index 00000000..8cd300c2
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Chapter24Test.java
@@ -0,0 +1,721 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import java.io.IOException;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter24Test {
+    @Test public void testColdLoopSelfConflict() { com.seaofnodes.simple.codegen.RegAllocTestSupport.coldLoopSelfConflict(); }
+
+    @Test public void testPrintingDeadFunction() throws Exception {
+        var code = new CodeGen("return 0;").parse();
+        var tfp = TypeFunPtr.TEST;
+        var fun = new FunNode(null,tfp,"deadPrinterTarget");
+        org.junit.Assert.assertTrue(fun.isDead());
+        code.link(fun);
+        var con = new ConstantNode(tfp);
+        var call = new CallNode(null,con,con,con);
+        con.toString();
+        call.name();
+
+        org.junit.Assert.assertSame(fun,code._link(tfp));
+        // Optimizer lookup still performs its usual lazy cleanup.
+        org.junit.Assert.assertNull(code.link(tfp));
+        org.junit.Assert.assertNull(code._link(tfp));
+    }
+
+
+    @Ignore
+    @Test
+    public void testJig() throws IOException {
+        String src = "int v0=0;  v0 = arg && 0== 0 !=0;";
+        testCPU(src,"x86_64_v2", "Win64"  ,-1,null);
+        testCPU(src,"riscv"    , "SystemV",-1,null);
+        testCPU(src,"arm"      , "SystemV",-1,null);
+    }
+
+    static CodeGen testCPU( String src, String cpu, String os, int spills, String stop ) {
+        CodeGen code = new CheckedCodeGen(src).driver(CodeGen.Phase.Encoding,cpu,os);
+        SpillStats.record(code,"Chapter24",cpu,os);
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+        if( stop != null )
+            assertEquals(stop, code._stop.toString());
+        return code;
+    }
+
+    @Test
+    public void testOr() throws IOException {
+        String src =
+"""
+int a = 1;
+int b = 0;
+
+if(a++ || b++ ) {
+    if(b == 0 && a == 2) {
+        sys.io.p("Or");
+    }
+} else{
+    sys.io.p("And");
+}
+return 0;
+""";
+
+        TestC.runSF("or1", src, null, "Or", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("or1", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Or",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("or1", src,0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Or",arm._stdout.toString());
+    }
+
+    @Test
+    public void testAnd() throws IOException {
+        String src =
+"""
+int a = 1;
+int b = 1;
+
+if(a && b) {
+    sys.io.p("And");
+} else {
+    sys.io.p("Or");
+}
+return 0;
+""";
+        TestC.runSF("and1", src, null, "And", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("and1", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("And",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("and1", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("And",arm._stdout.toString());
+    }
+
+    @Test
+    public void testAndPtr() throws IOException {
+        // Todo: have one src here
+        String src =
+"""
+struct S { !S? !fld; };
+val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};};
+return ptr && ptr.fld ? "true" : "false";
+""";
+        String src2 =
+"""
+struct S { !S? !fld; };
+
+val ptr = arg == 1 ? null : new S{fld = arg==1 ? null : new S{fld = null;};};
+if( ptr && ptr.fld ) {
+  sys.io.p("true");
+} else {
+  sys.io.p("false");
+}
+
+return 0;
+""";
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("[97-117][ 116,114,117,101]", Eval2.eval(code, 0));
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("ptrand",src2, 1, 8, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("false",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("ptrand", src2, 1, 8, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("false",arm._stdout.toString());
+    }
+
+    // conditional side effect
+    @Test
+    public void testCondSideEffAnd() throws IOException {
+        String src =
+"""
+int a = 1;
+int b = 1;
+
+int x=1;
+int y=1;
+int z=0;
+
+int g = x++ && y++ && z++;
+
+if(x == 2 && y == 2 && z == 1 && g == 0) {
+    sys.io.p("Effected");
+} else {
+    sys.io.p("Not effected");
+}
+return 0;
+""";
+
+        TestC.runSF("and2", src, null, "Effected", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("and2", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Effected",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("and2", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Effected",arm._stdout.toString());
+    }
+
+
+    @Test
+    public void testCondSideEffOr() throws IOException {
+        String src =
+"""
+int a = 1;
+int b = 1;
+
+int x = -1;
+int y=1;
+int z= -1;
+
+int g = x++ || y++ || z++;
+
+int switch = 0;
+if(x == 4 || y == 4 || z == 4) {
+    switch = -1;
+} else {
+    switch = 1;
+}
+int cd = 1;
+if((x == 0 && y == 1 && z==-1) && switch && g) {
+    sys.io.p("Effected");
+} else {
+    sys.io.p("Not effected");
+}
+return 0;
+""";
+        TestC.runSF("or2", src, null, "Effected", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("or2", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Effected",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("or2", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Effected",arm._stdout.toString());
+    }
+
+    // test it with function calls
+    @Test
+    public void testFuncCall() throws IOException {
+        String src =
+"""
+// -*- mode: java;  -*-
+int a = 1;
+int b = 1;
+
+var sq = { int x ->
+    x*x;
+};
+
+if(a && sq(0)) {
+    sys.io.p("And");
+} else {
+    sys.io.p("Or");
+}
+return 0;
+""";
+        TestC.runSF("and3", src, null, "Or", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("and3", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Or",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("and3", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Or",arm._stdout.toString());
+    }
+
+    // test it with function calls
+    @Test
+    public void testStack1() throws IOException {
+        String src =
+"""
+int something_specific = 11;
+
+if (10 < something_specific < 20) {
+    sys.io.p("In Range");
+} else {
+   sys.io.p("Out of Range");
+}
+return 0;
+""";
+
+        TestC.runSF("stacked_r_1", src, null, "In Range", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_1", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("In Range",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_1", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("In Range",arm._stdout.toString());
+    }
+
+    @Test
+    public void testStack2() throws IOException {
+        String src =
+"""
+int score = 75;
+
+if (60 <= score < 90) {
+    sys.io.p("In Range");
+} else {
+sys.io.p("Out of range");
+}
+return 0;
+""";
+
+        TestC.runSF("stacked_r_2", src, null, "In Range", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_2", src, 0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("In Range",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_2", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("In Range",arm._stdout.toString());
+    }
+
+    @Test
+    public void testStack3() throws IOException {
+        String src =
+"""
+var sq = { int x ->
+    x*x;
+};
+
+int score = 5;
+
+val str = (sq(2) <= score < sq(3)) ? "In Range" : "Out of range";
+sys.io.p(str);
+return 0;
+""";
+
+        TestC.runSF("stacked_r_3", src, null, "In Range", 5);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_3", src, 0, 5, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("In Range",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_3", src, 0, 5, false);
+        int trap_1 = arm.step(100);
+        assertEquals(0,trap_1);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("In Range",arm._stdout.toString());
+    }
+
+    @Test
+    public void testStack4() throws IOException {
+        String src =
+"""
+int something_specific = 9;
+
+if (10 < something_specific < 20) {
+    sys.io.p("In Range");
+} else {
+   sys.io.p("Out of Range");
+}
+return 0;
+""";
+
+        TestC.runSF("stacked_r_4", src, null, "Out of Range", 0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_4", src,0, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("Out of Range",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_4", src, 0, 2, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("Out of Range",arm._stdout.toString());
+    }
+
+    @Test
+    public void testStack5() throws IOException {
+        String src =
+"""
+var sq = { int x ->
+    x*x;
+};
+
+int score = 5;
+
+if (sq(2) <= score < sq(3)) {
+sys.io.p("In Range");
+} else {
+sys.io.p("Out of range");
+}
+
+return 0;
+""";
+        TestC.runSF("stacked_r_5", src, null, "In Range", 5);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_5", src, 0, 7, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,R5.regs[riscv.A0]);
+        assertEquals("In Range",R5._stdout.toString());
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_5", src, 0, 7, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(0,arm.regs[0]);
+        assertEquals("In Range",arm._stdout.toString());
+    }
+
+
+    @Test
+    public void testStack6() {
+        try { new CodeGen(
+                    """
+                        return 0 < arg > 1;
+                        """
+        ).parse(); fail(); }
+        catch( RuntimeException e ) { assertEquals("Mixing relational directions in a chained relational test",e.getMessage()); }
+    }
+
+    @Test
+    public void testStack9() throws IOException {
+        String stack9 = "1";
+        String src =
+"""
+var stack9 = { int x ->
+    (x < 1) == 1;
+};
+""";
+        String src2 =
+"""
+return (0 < 1) == 1;
+""";
+        TestC.run(src, "stacked_r_9x", null, stack9,0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_9", src2, 0, 0, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,R5.regs[riscv.A0]);
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_9", src2, 0, 0, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,arm.regs[0]);
+    }
+
+    @Test
+    public void testStack10() throws IOException {
+        String stack10 = "1";
+        String src =
+"""
+var stack10 = { int x ->
+    (x < 1) == (1>x);
+};
+""";
+    String src2 =
+"""
+return (0 < 1) == (1>0);
+""";
+        TestC.run(src, "stacked_r_10x", null, stack10,0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_10", src2, 0, 0, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,R5.regs[riscv.A0]);
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_10", src2,0, 0, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,arm.regs[0]);
+    }
+
+    @Test
+    public void testStack11() throws IOException {
+        String stack11 = "1";
+        String src =
+"""
+var stack11 = { int x ->
+    0 < x < x+1 < 4;
+};
+""";
+        String src2 =
+"""
+return 0 < arg < arg+1 < 4;
+""";
+        TestC.run(src, "stacked_r_11x", null, stack11,2);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_11", src2, 1, 2, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,R5.regs[riscv.A0]);
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_11", src2, 1, 0, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,arm.regs[0]);
+    }
+
+    // shows that it is parsed as
+    // ((0 != x) != 2)
+    @Test
+    public void testStack12() throws IOException {
+        String stack11 = "1";
+        String src =
+                """
+                var stack12 = { int x ->
+                    0 != x != 2;
+                };
+                """;
+        String src2 =
+                """
+                return 0 != arg != 2;
+                """;
+        TestC.run(src, "stacked_r_12x", null, stack11,0);
+
+        // Evaluate on RISC5 emulator
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_12", src2, 1, 0, false);
+        int trap = R5.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,R5.regs[riscv.A0]);
+
+        // Evaluate on ARM emulator
+        EvalArm64 arm = TestArm64.build("stacked_r_12", src2, 1, 0, false);
+        trap = arm.step(100);
+        assertEquals(0,trap);
+        assertEquals(1,arm.regs[0]);
+    }
+
+
+    // shows that it is parsed as
+    // ((0 == x) == 1)
+    @Test
+    public void testStack13() throws IOException {
+        String stack12 = "1";
+        String src =
+                """
+                var stack13 = { int x ->
+                    0 == x == 1;
+                };
+                """;
+        String src2 =
+                """
+                return 0 == arg == 1;
+                """;
+        TestC.run(src, "stacked_r_13x", null, stack12,0);
+
+        // Compile once per target, then check false, true and negative inputs.
+        EvalRisc5 R5 = TestRisc5.build("stacked_r_13", src2, 1, 0, false);
+        for( int arg : new int[]{-1,0,1} ) {
+            R5._pc = 0;
+            R5.regs[riscv.A0] = arg;
+            assertEquals(0,R5.step(100));
+            assertEquals(arg==0 ? 1 : 0,R5.regs[riscv.A0]);
+        }
+        EvalArm64 arm = TestArm64.build("stacked_r_13", src2, 1, 0, false);
+        for( int arg : new int[]{-1,0,1} ) {
+            arm._pc = 0;
+            arm.regs[0] = arg;
+            assertEquals(0,arm.step(100));
+            assertEquals(arg==0 ? 1 : 0,arm.regs[0]);
+        }
+    }
+
+    @Test
+    public void testFRefFields() {
+        String src =
+"""
+// A hypothetical scanner class
+struct Scan {
+    int !x;
+    u8[~] !buf;
+    // Skip whitespace
+    val skip = { !Scan s ->
+        while( s.buf[s.x] <= ' ' )
+            s.x++;
+    };
+    // Peek a character; if matched consume it, else false.
+    val peek = { !Scan !s, u8 c ->
+        skip(s);
+        if( s.buf[s.x] != c ) return false;
+        s.x++;
+        return true;
+    };
+};
+!Scan !s = new Scan{ buf = "  q"; };
+return Scan.peek(s,'q');
+""";
+
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return Phi(Region,0,1);", code._stop.toString());
+        assertEquals("1", Eval2.eval(code, 0));
+        testCPU(src,"x86_64_v2", "Win64"  ,23,null);
+    };
+
+    @Test
+    public void testFRefFields2() {
+        String src =
+"""
+// A hypothetical scanner class
+struct Scan {
+    int !x;
+    u8[~] !buf;
+    // Skip whitespace
+    val skip = { ->
+        while( buf[x] <= ' ' )
+            x++;
+        return self;
+    };
+};
+~Scan s = new Scan{ buf = "  q"; };
+return s.skip().x;
+""";
+
+        try { new CodeGen(src).driver(CodeGen.Phase.TypeCheck); fail(); }
+        catch( Exception e ) { org.junit.Assert.assertTrue(e.getMessage().startsWith("Argument #0 isa")); }
+    };
+
+
+    @Test
+    public void testMethod() {
+        String src =
+"""
+// A hypothetical scanner class
+struct Scan {
+    int !x;
+    u8[~] !buf;
+    // Skip whitespace
+    val skip = { ->
+        while( buf[x] <= ' ' )
+            x++;
+    };
+    val require = { u8 ch ->
+        skip();
+        buf[x++]==ch;
+    };
+};
+!Scan !s = new Scan{ buf = "  [1,2]"; };
+return s.require('[');
+""";
+
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return (.[]==91);", code._stop.toString());
+        assertEquals("1", Eval2.eval(code, 0));
+        testCPU(src,"x86_64_v2", "Win64"  ,4,null);
+    };
+
+    @Test
+    public void testSCCP0() {
+        String src =
+"""
+int x = 1;
+int cnt = 5;
+while (cnt) {
+  cnt -= 1;
+  if (x == 0) {
+    x += 1;
+  }
+}
+return x;
+""";
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 1;", code._stop.toString());
+    }
+
+    @Test
+    public void testSCCP1() {
+        String src =
+"""
+int x = 1;
+int cnt = 5;
+while( cnt-- )
+  if( x == 1 )
+    x = 2-x;
+return x;
+""";
+        CodeGen code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals("return 1;", code._stop.toString());
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Compile.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Compile.java
new file mode 100644
index 00000000..f3ca1905
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Compile.java
@@ -0,0 +1,65 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.FunNode;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Compile {
+
+    private static Process run(String simple, String c) throws IOException, InterruptedException {
+        boolean USE_WSL = System.getProperty("os.name").startsWith("Windows");
+        CodeGen code = new CodeGen(simple);
+        code.driver(CodeGen.Phase.Encoding,"x86_64_v2","SystemV");
+        if (c != null) for (var n:code._start._outputs) if (n instanceof FunNode f && f._name.equals("main")) f._name = "simple_main";
+        code.exportELF("test.o");
+        var params = new ArrayList<String>();
+        if (USE_WSL) params.add("wsl.exe");
+        params.add("gcc");
+        params.add("-o");
+        params.add("test");
+        if (c != null) {
+            Files.writeString(Path.of("test.c"), c);
+            params.add("test.c");
+        }
+        params.add("test.o");
+        Process p = Runtime.getRuntime().exec(params.toArray(String[]::new));
+        assertEquals(0, p.waitFor());
+        return Runtime.getRuntime().exec(USE_WSL ? new String[]{"wsl.exe", "./test"}:new String[]{"./test"});
+    }
+
+    @Test
+    @Ignore
+    public void testCompile() throws IOException, InterruptedException {
+        var p = run("""
+                val testMy = { flt x ->
+                    flt guess = x;
+                    while( 1 ) {
+                        flt next = (x/guess + guess)/2;
+                        if( next == guess ) return guess;
+                        guess = next;
+                    }
+                };
+                ""","""
+
+                #include <stdio.h>
+
+                extern double testMy(double);
+
+                int main(int argc, char** argv) {
+                    printf("%f\\n", testMy(2.0));
+                    return 0;
+                }
+
+                """);
+        assertEquals(0, p.waitFor());
+        assertEquals("1.414214\n", new String(p.getInputStream().readAllBytes(), StandardCharsets.UTF_8));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/CompoundAssignmentTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/CompoundAssignmentTest.java
new file mode 100644
index 00000000..e2d822d0
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/CompoundAssignmentTest.java
@@ -0,0 +1,94 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class CompoundAssignmentTest {
+    private static final String[] OPS = {"&=", "|=", "^=", "<<=", ">>=", ">>>="};
+
+    private static long apply(String op, long lhs, long rhs) {
+        return switch (op) {
+            case "&=" -> lhs & rhs;
+            case "|=" -> lhs | rhs;
+            case "^=" -> lhs ^ rhs;
+            case "<<=" -> lhs << rhs;
+            case ">>=" -> lhs >> rhs;
+            case ">>>=" -> lhs >>> rhs;
+            default -> throw new AssertionError(op);
+        };
+    }
+
+    @Test public void testLocals() {
+        for (String op : OPS)
+            for (long arg : new long[]{-8, 0, 5, 64}) {
+                long expected = apply(op, arg, 3);
+                check("int x=arg; int r=(x " + op + " 3); return x*10+r;",
+                      arg, expected*11);
+            }
+    }
+
+    @Test public void testRhsOnce() {
+        for (String op : OPS) {
+            long expected = apply(op, 5, 1);
+            check("int x=arg; int count=0; int r=(x " + op +
+                  " (count=count+1)); return count*1000+x*10+r;", 5, 1000+expected*11);
+        }
+    }
+
+    @Test public void testNarrowingAndChaining() {
+        check("u8 x=255; x <<= 1; return x;", 0, 254);
+        check("u8 x=255; x ^= 256; return x;", 0, 255);
+        check("int x=1; int y=3; x |= y <<= 2; return x*100+y;", 0, 1312);
+        check("int x=-8; x >>= 65; return x;", 0, -4);
+        check("int x=-8; x >>>= 65; return x;", 0, Long.MAX_VALUE-3);
+    }
+
+    @Test public void testExistingOperators() {
+        check("int x=8; x+=2; x-=1; x*=3; x/=9; return x;", 0, 3);
+        check("int x=arg; int y=x++; int z=x--; return x*100+y*10+z;", 5, 556);
+        check("return (arg << 2) + (arg >> 1) + (arg >>> 1);", 8, 40);
+        check("return arg <= 8;", 8, 1);
+        check("return arg >= 8;", 8, 1);
+    }
+
+    @Test public void testRejectedAssignments() {
+        for (String op : OPS) {
+            rejected("val x=3; x " + op + " 1; return x;");
+            rejected("int x=3; x " + op + " 1.5; return x;");
+        }
+    }
+
+    private static void rejected(String src) {
+        try {
+            check(src, 0, 0);
+            fail("Accepted invalid assignment: " + src);
+        } catch (RuntimeException e) {
+            assertTrue("Must report a language error: " + e, e instanceof Parser.ParseException);
+            assertNotNull(e.getMessage());
+            assertFalse("Must report a language error: " + e, e.getMessage().contains("Not yet implemented"));
+        }
+    }
+
+    @Test public void testFields() {
+        for (String op : OPS) {
+            long expected = apply(op, -8, 3);
+            check("struct S { int x; }; !S !s=new S; s.x=arg; int r=(s.x " +
+                  op + " 3); return s.x*10+r;", -8, expected*11);
+        }
+    }
+
+    @Test public void testArrayAddressAndRhsOnce() {
+        for (String op : OPS) {
+            long expected = apply(op, 5, 1);
+            check("int[] !a=new int[2]; a[0]=arg; int i=0; int count=0; " +
+                  "int r=(a[i++] " + op + " (count=count+1)); " +
+                  "return i*1000+count*100+a[0]*10+r;", 5, 1100+expected*11);
+        }
+    }
+
+    private static void check(String src, long arg, long expected) {
+        var code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals(src, Long.toString(expected), Eval2.eval(code, arg));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Eval2.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Eval2.java
new file mode 100644
index 00000000..98e0f18a
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Eval2.java
@@ -0,0 +1,489 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.print.IRPrinter;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.SB;
+import com.seaofnodes.simple.util.Utils;
+import java.util.*;
+
+public abstract class Eval2 {
+
+    // A mapping from Node ID to evaluation data Object.
+    // Data Objsts are a boxed Long or Double; or an Object[] of fields, which
+    // themselves are just more Objects.
+    private static class Frame {
+        private static int UID=1;
+
+        private final IdentityHashMap<Node,Object> _data;
+        private Frame _prior;   // Prior frame in this sequence, means when making a new frame we can find old stuff
+        private int _refcnt;    // TODO: Use this in a sentence (free/recycle unused stack frames)
+        final int _uid = UID++; // Debugging aid
+        Frame(Frame prior) {
+            _prior = prior;
+            if( prior!=null ) prior._refcnt++;
+            _data = new IdentityHashMap<>();
+            _refcnt = 1;
+        }
+
+        // Dec ref count
+        void dec() {
+            assert _refcnt>0;
+            if( --_refcnt == 0 ) {
+                Frame prior = _prior;
+                _prior = null;
+                _data.clear();
+                // TODO: FREE LIST?
+                if( prior!=null )
+                    prior.dec();
+            }
+        }
+
+        // Put a mapping from Node->Object
+        Node put(Node n, Object d) {
+            assert d!=null;
+            return put0(n,d);
+        }
+        // Put a mapping from Node->Object?
+        Node put0(Node n, Object d) {
+            assert _refcnt>0;
+            _data.put(n,d);
+            return n;
+        }
+        // Get a mapped Node, perhaps using the prior stack frame crawl
+        Object get(Node n) {
+            assert _refcnt>0;
+            Object d = _data.get(n);
+            return d != null ? d
+                : _prior == null ? null
+                : _prior.get(n);
+        }
+
+        // Short debugging print
+        public String p() {
+            return "#"+_uid + (_prior==null ? "" : " >> " + _prior.p());
+        }
+        // Long debugging print
+        @Override public String toString() {
+            String s = "";
+            if( _prior != null ) s+= _prior+" << ";
+            s += "#"+_uid+"[ ";
+            for( Node n : _data.keySet() )
+                s += n + ":" + _data.get(n) + ",";
+            s += "]";
+
+            return s;
+        }
+    }
+
+    // Classic Closure; an environment (stack of frames) and an execution point
+    private static class Closure {
+        // Where to return too; either a CallEnd or a Function
+        final CFGNode _cc;
+
+        // Stack frame at the execution point.  Includes Closures which
+        // recursively include other stack frames
+        private Frame _frame;
+
+        Closure(CFGNode cc, Frame frame) {
+            _cc = cc;           // One of Fun, CallEnd or Stop (null)
+            _frame = frame;
+            assert _frame._refcnt >=0;
+            _frame._refcnt++;
+        }
+
+        FunNode fun() { return (FunNode)_cc; }
+        CallEndNode cend() { return (CallEndNode)_cc; }
+        boolean isStop() { return _cc instanceof StopNode; } // or Stop
+
+        //
+        void pushFrame() {
+            _frame = new Frame(_frame);
+            _frame._refcnt++;
+        }
+
+        @Override public String toString() {
+            return _cc.toString();
+        }
+    }
+
+    // CodeGen has the linker tables
+    public static CodeGen CODE;
+
+    // Current active Frame, to avoid having to pass it everywhere
+    public static Frame F;
+
+    public static String eval( CodeGen code, long arg ) { return eval(code,arg,1000); }
+    public static String eval( CodeGen code, long arg, int timeout ) {
+        if( code._start.uctrl()==null ) return ""; // The empty program
+        SB trace = null; // = new SB(); // TRACE, set to null for off, new SB() for on
+        // Force local scheduling phase
+        code.driver(CodeGen.Phase.LocalSched);
+        // Set global, so don't have to pass everywhere
+        CODE = code;
+
+        // Timer for when we run too long.  Ticks once per backedge or function call
+        int loopCnt = 0;
+
+        // Current value for each Node; boxed Long or Double; or an Object[] of
+        // fields, which themselves are just more Objects.
+        F = new Frame(null);
+
+        // Start at the START
+        CFGNode BB = code._start, prior = null;
+        // Return from main hits Stop
+        F.put(BB,new Closure(code._stop,F));
+
+
+        // ------------
+        // Evaluate until exit or timeout.  Each outer loop step computes
+        // all data nodes under some new Control.
+        while( true ) {
+            assert BB!=null;
+            traceCtrl(BB,trace);
+            if( trace!=null ) System.out.println(F.p());
+
+            // Parallel assign Phis
+            int i = BB instanceof RegionNode r
+                    ? parallelAssignPhis(r,prior,arg,trace)
+                    : 0;
+
+            // Compute the data nodes until BB control
+            for( ; i < BB.nOuts(); i++ )
+                if( !(BB.out(i) instanceof CFGNode) )
+                    step(BB.out(i), trace);
+
+            // Find the next control target
+            prior = BB;
+            BB = BB.uctrl();      // Next unique control target
+            switch( prior ) {
+            case StartNode start:  F = new Frame(F); break; // Frame for the call to main, as-if Called
+            case CallNode  call :  BB = call(call); break;
+            case NeverNode never:  BB = never.cproj(0); break; // Synthetic exit is never taken.
+            case IfNode    iff  :  Object p = val(iff.pred()); BB = iff.cproj( p==null || (p instanceof Long x && x==0L)  ? 1 : 0);  break;
+            case ReturnNode ret :  if( clj(ret.rpc()).isStop() ) return exit(ret); else BB = ret(ret); break;
+            case FunNode   fun  :  if( loopCnt++ > timeout ) return null;  break; // Timeout
+            case LoopNode  loop :  if( loopCnt++ > timeout ) return null;  break; // Timeout
+            case CallEndNode cend: break;
+            case CProjNode cproj:  break;
+            case RegionNode r   :  break;
+            default:               throw Utils.TODO();
+            }
+            assert !BB.isDead();
+        }
+    }
+
+
+    // Phi cache; size is limited to number of Phis at a merge point
+    private static final Object[] PHICACHE = new Object[256];
+    static int parallelAssignPhis(RegionNode r, CFGNode prior, long arg, SB trace) {
+
+        // Compute input path on Phis for this Region
+        int path = r._inputs.find( prior );
+        // Parameters read from prior frame, Phis from local frame
+        Frame frame = (r instanceof FunNode ? F._prior : F);
+        boolean isMain = r instanceof FunNode fun && fun.sig().isa(CodeGen.CODE._main);
+
+        // Parallel assign Phis.  First parallel read and cache
+        int i;
+        for( i = 0; i < r.nOuts(); i++ ) {
+            if( !(r.out(i) instanceof PhiNode phi) ) break;
+            if( isMain && phi instanceof ParmNode parm && parm._idx==2 )
+                PHICACHE[i] = arg; // Reading the initial arguments to main()
+            else {
+                Node n = phi instanceof ParmNode parm
+                    // RPC reads the Call directly;
+                    // Parms may not be linked, so read call args directly
+                    ? (parm._idx==0 ? prior : prior.in(parm._idx))
+                    // Phis read from path input
+                    :  phi.in(path);
+                PHICACHE[i] = frame.get(n);
+            }
+        }
+        // Parallel assign; might assign before read, so read from cache
+        for( int j=0; j < i; j++ )
+            traceData(F.put0(r.out(j),PHICACHE[j]),trace);
+        // Return point in basic block past last Phi
+        return i;
+    }
+
+
+    // Make a call.
+    private static CFGNode call( CallNode call ) {
+        // Set up the Return PC and return frame (which is just the current frame).
+        // Really making a Continuation, but it's just a Closure
+        Closure cont = new Closure(call.cend(),F);
+        // Set the return continuation into the current frame RPC
+        F.put(call, cont );
+        // Next Frame to use
+        F = new Frame(F);
+        // Target function and environment
+        return CODE.link(tfp(call.fptr()));
+    }
+
+    private static CFGNode ret( ReturnNode ret ) {
+        // Fetch return expression value and continuation from current frame
+        Object rez = val(ret.expr());
+        Closure cont = clj(ret.rpc());
+        // Lower Frame reference count; might delete frame
+        F.dec();                // Lower ref count
+        // Install replacement Frame; set return result over the CallEnd
+        F = cont._frame;
+        F.put0(cont._cc,rez);   // Set return value into CallEnd
+        return cont._cc;        // Return CallEnd as the new control
+    }
+
+    private static String exit( ReturnNode ret ) {
+        return prettyPrint(ret.expr()._type,val(ret.expr()));
+    }
+
+    // Take a worklist step: one data op from the current Control is updated.
+    private static void step(Node n, SB trace) {
+        if( n instanceof PhiNode ) return;
+        // Compute new value
+        F.put0(n,compute(n));
+        traceData(n,trace);
+        // Also do any following projections, which are not in the local schedule otherwise
+        if( n instanceof MultiNode )
+            for( Node use : n._outputs )
+                step(use,trace);
+    }
+
+    // From here down shamelessly copied from Evaluator, written by @Xmilia
+    private static Object compute( Node n ) {
+        return switch( n ) {
+        case AddFNode     adf  -> d(adf.in(1)) +  d(adf.in(2));
+        case AddNode      add  -> x(add.in(1)) +  x(add.in(2));
+        case AndNode      and  -> x(and.in(1)) &  x(and.in(2));
+        case BoolNode.EQF eqf  -> d(eqf.in(1)) == d(eqf.in(2)) ? 1L : 0L;
+        case BoolNode.LEF lef  -> d(lef.in(1)) <= d(lef.in(2)) ? 1L : 0L;
+        case BoolNode.LTF ltf  -> d(ltf.in(1)) <  d(ltf.in(2)) ? 1L : 0L;
+        case BoolNode.EQ  eq   -> Objects.equals(val(eq.in(1)), val(eq.in(2))) ? 1L : 0L; // Bool EQ supports pointers, nil, and integers
+        case BoolNode.LE  le   -> x(le .in(1)) <= x(le .in(2)) ? 1L : 0L;
+        case BoolNode.LT  lt   -> x(lt .in(1)) <  x(lt .in(2)) ? 1L : 0L;
+        case CastNode    cast  -> val(cast.in(1));
+        case ConstantNode con  -> con(con._con);
+        case DivFNode     dvf  -> d(dvf.in(2))==0 ? 0D : d(dvf.in(1)) /  d(dvf.in(2));
+        case DivNode      div  -> x(div.in(2))==0 ? 0L : x(div.in(1)) /  x(div.in(2));
+        case LoadNode     ld   -> load(ld);
+        case MinusFNode   mnf  -> - d(mnf.in(1));
+        case MinusNode    sub  -> - x(sub.in(1));
+        case MulFNode     mlf  -> d(mlf.in(1)) *  d(mlf.in(2));
+        case MulNode      mul  -> x(mul.in(1)) *  x(mul.in(2));
+        case NewNode      alloc-> alloc(alloc);
+        case NotNode      not  -> not(not);
+        case OrNode       or   -> x(or .in(1)) |  x(or .in(2));
+        case ProjNode     proj -> proj._type instanceof TypeMem ? "$mem" : val(proj.in(0));
+        case ReadOnlyNode read -> val(read.in(1));
+        case SarNode      sar  -> x(sar.in(1)) >> x(sar.in(2));
+        case MemMergeNode merge-> "$mem";
+        case ShlNode      shl  -> x(shl.in(1)) << x(shl.in(2));
+        case ShrNode      shr  -> x(shr.in(1)) >>>x(shr.in(2));
+        case StoreNode    st   -> store(st);
+        case SubNode      sub  -> x(sub.in(1)) -  x(sub.in(2));
+        case SubFNode     sbf  -> d(sbf.in(1)) -  d(sbf.in(2));
+        case RoundF32Node rnd  -> (double)(float)d(rnd.in(1));
+        case ToIntegerNode cvt -> (long)d(cvt.in(1));
+        case ToFloatNode  toflt-> (double)x(toflt.in(1));
+        case XorNode      xor  -> x(xor.in(1)) ^  x(xor.in(2));
+        default -> throw Utils.TODO();
+        };
+    }
+
+    private static Object not( NotNode not ) {
+        Object n = val(not.in(1));
+        return ( n==null || (n instanceof Double D && D==0.0) || n instanceof Long L && L==0 )
+            ? 1L : 0L;
+    }
+
+    // Fetch without unboxing, searching up-Frame
+    static Object val( Node n ) { return F.get(n); }
+    // Fetch and unbox as primitive long
+    static long   x( Node n ) { Object d = F.get(n); return d==null ? 0 : (Long)d;  }
+    // Fetch and unbox as primitive double
+    static double d( Node n ) { Object d = F.get(n); return d==null ? 0 : (Double)d;  }
+    // Fetch and unbox a function constant
+    static TypeFunPtr tfp(Node n) { return (TypeFunPtr)F.get(n); }
+    // Fetch and unbox a closure
+    static Closure clj(Node n) { return (Closure)F.get(n); }
+
+    // Java box ints and floats.  Other things can just be null or some informative string
+    private static Object con( Type t ) {
+        return switch ( t ) {
+        case TypeInteger i -> i.isConstant() ? (Long  )i.value() : "INT";
+        case TypeFloat   f -> f.isConstant() ? (Double)f.value() : "FLT";
+        case TypeFunPtr tfp -> tfp;
+        case TypeMem mem -> "MEM";
+        case TypeMemPtr tmp -> {
+            // Unknown-caller inputs are type placeholders, not heap constants.
+            if( !tmp.isConstant() ) yield tmp;
+            if( tmp._obj.isAry() ) { // Constant array ptr
+                Type elem = tmp._obj.field("[]")._t;
+                if( elem instanceof TypeConAry con ) {
+                    Object[] xs = new Object[con.len()];
+                    for( int i=0; i<con.len(); i++ )
+                        xs[i] = con.at8(i);
+                    yield xs;
+                } else {
+                    // Generic constant array, used as a default input to a
+                    // function; should never execute.
+                    yield new Object[0];
+                }
+
+            } else {
+                // Generic TMP (since Simple is not currently making actual
+                // memory constants), used as a default input to a function;
+                // should never execute.
+                yield tmp.toString();
+            }
+        }
+        default -> null;
+        };
+    }
+
+    // Convert array size to array element count
+    private static int offToIdx( long off, TypeStruct t) {
+        off -= t.aryBase();
+        int scale = t.aryScale();
+        assert (off & ((1L << scale)-1)) == 0;
+        return (int)(off>>scale);
+    }
+
+    // Builds and returns a pointer Object
+    private static Object alloc(NewNode alloc) {
+        TypeStruct type = alloc._ptr._obj;
+        if( type.isAry() ) {
+            long sz = (Long)val(alloc.size());
+            long x = offToIdx(sz, type);
+            int n = (int)x;
+            if( n!=x || n<0 )
+                throw new NegativeArraySizeException(""+n);
+            Object[] ary = new Object[n]; // Array body
+            var elem = type._fields[1]._t;
+            if (elem instanceof TypeInteger) {
+                Arrays.fill( ary, 0L );
+            } else if (elem instanceof TypeFloat) {
+                Arrays.fill( ary, 0D );
+            } else {
+                assert elem instanceof TypeMemPtr || elem instanceof TypeFunPtr;
+            }
+            return ary;
+        }
+
+        int num = type._fields.length;
+        Object[] ptr = new Object[num];
+        for( int i=0; i<num; i++ )
+            ptr[i] = con(type._fields[i]._t.makeZero());
+        return ptr;
+    }
+
+    private static Object load( LoadNode ld ) {
+        Object f = val(ld.ptr());
+        // Check for dense constant array
+        if( f instanceof TypeMemPtr tmp ) {
+            //assert tmp._obj._con != TypeConAry.BOT;
+            //if( ld._name.equals("#") )
+            //    return (long)tmp._obj._con.len();
+            //int idx = offToIdx(x(ld.off()),tmp._obj);
+            //return tmp._obj._con.at(idx);
+            throw Utils.TODO();
+        }
+        Object[] fs = (Object[])f;
+        if( ld._name.equals("#") )
+            return (long)fs.length;
+        TypeMemPtr tmp = (TypeMemPtr)ld.ptr()._type;
+        int idx = tmp._obj.isAry()
+            ? offToIdx(x(ld.off()),tmp._obj)
+            : tmp._obj.find(ld._name);
+        return fs[idx];
+    }
+
+    private static Object store( StoreNode st ) {
+        if( st._name.equals("#") )
+            return "$mem";      // Eval stores the length in the java object[], no need to set it now
+        TypeMemPtr tmp = (TypeMemPtr)st.ptr()._type;
+        Object[] fs = (Object[])val(st.ptr());
+        int idx = tmp._obj.isAry()
+            ? offToIdx(x(st.off()),tmp._obj)
+            : tmp._obj.find(st._name);
+        Object val = val(st.val());
+        fs[idx] = val;
+        return "$mem";
+    }
+
+
+    // ------------------------------------------------------------------------
+    private static final IdentityHashMap<Object,Object> VISIT = new IdentityHashMap<>();
+
+
+    static void traceCtrl( CFGNode BB, SB sb ) {
+        if( sb==null ) return;
+        IRPrinter.printLine(BB,sb.p("--- "));
+        System.out.print(sb);
+        sb.clear();
+    }
+    static void traceData( Node n, SB sb ) {
+        if( sb==null ) return;
+        IRPrinter.printLine(n,sb).unchar();
+        _print( n._type, F.get(n), sb.p('\t'), VISIT );
+        System.out.println(sb);
+        sb.clear();
+        VISIT.clear();
+    }
+
+    // Use type to print x as a string.  Uses a new VISIT table so the debugger
+    // doesn't try to reuse VISIT if stopping mid-print.  The trace code reuses
+    // VISIT endlessly for some minor speed hope
+    static String prettyPrint( Type t, Object x ) { return _print(t,x,new SB(), new IdentityHashMap<>()).toString(); }
+    static SB _print( Type t, Object x, SB sb, IdentityHashMap<Object,Object> visit ) {
+        if( x instanceof String s ) return sb.p(s);
+        if( x == null ) return sb.p("null");
+        return switch( t ) {
+        case TypeInteger i -> sb.p(  (Long)x);
+        case TypeFloat   f -> sb.p((Double)x);
+        case TypeMemPtr tmp -> {
+            if( visit.containsKey(x) ) yield sb.p("$cyclic");
+            visit.put(x,x);
+            assert !tmp.isFRef();
+
+            Object[] xs = (Object[])x; // Array of fields
+            if( tmp._obj.isAry() ) {
+                Type elem = tmp._obj._fields[1]._t;
+                if( elem == TypeInteger.U8 ) {
+                    // Shortcut u8[] as a String
+                    for( Object o : xs )
+                        sb.p((char)(long)(Long)o);
+                } else {
+                    // Array of elements
+                    elem.print(sb).p("[ ");
+                    if( elem instanceof TypeConAry ) elem = TypeInteger.ZERO;
+                    for( Object o : xs )
+                        _print( elem, o, sb, visit ).p( "," );
+                    sb.unchar().p("]");
+                }
+            } else {
+                sb.p(tmp._obj._name).p("{");
+                Field[] flds = tmp._obj._fields;
+                for( int i=0; i<flds.length; i++ )
+                    _print( flds[i]._t,xs[i], sb.p(flds[i]._fname).p("="), visit ).p(",");
+                sb.unchar().p("}");
+            }
+            yield sb;
+        }
+        case TypeFunPtr tfp -> sb.p(x.toString());
+        case TypeRPC rpc -> sb.p(x.toString());
+        case TypeMem mem -> sb.p("$mem");
+        case TypeTuple tt -> {
+            if( tt._types.length>1 && tt._types[0] instanceof TypeMemPtr )
+                // Assume a NewNode
+                yield _print( tt._types[0], x, sb, visit );
+            throw Utils.TODO();
+        }
+        case Type tt -> {
+            if( tt == Type.NIL ) yield sb.p("null");
+            throw Utils.TODO();
+        }
+        };
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/FuzzerWrap.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/FuzzerWrap.java
new file mode 100644
index 00000000..b022bec9
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/FuzzerWrap.java
@@ -0,0 +1,58 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.fuzzer.Fuzzer;
+import java.util.Random;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Normal tests run chapter-local regression seeds. Open failures and exploratory
+ * fuzzing are opt-in (run directly in the IDE or temporarily remove Ignore).
+ * Seeds depend on this chapter's generator; do not copy them between chapters.
+ */
+public class FuzzerWrap {
+
+    private static final long[] REGRESSION_SEEDS = {
+    };
+
+    private static final long[] OPEN_FAILING_SEEDS = {
+    };
+
+    @Test         public void fuzzPeepsRegression  () { fuzzPeepsSeeds(REGRESSION_SEEDS); }
+    @Test @Ignore public void fuzzPeepsOpenFailures() { fuzzPeepsSeeds(OPEN_FAILING_SEEDS); }
+
+    private static void fuzzPeepsSeeds(long... seeds) {
+        var fuzzer = new Fuzzer();
+        for (long seed : seeds)
+            fuzzer.fuzzPeepsRegression(seed);
+    }
+
+    @Ignore
+    @Test
+    public void fuzzPeepsLarge() {
+        var fuzzer = new Fuzzer();
+        for (int i=0; i<1000000; i++)
+            fuzzer.fuzzPeeps(i);
+        assertTrue(fuzzer.noExceptions());
+    }
+
+
+    @Test @Ignore
+    public void fuzzPeepsRandom() {
+        Random R = new Random(System.currentTimeMillis());
+        var fuzzer = new Fuzzer();
+        for (int i=0; i<100; i++)
+            fuzzer.fuzzPeeps( R.nextLong());
+        assertTrue(fuzzer.noExceptions());
+    }
+
+    @Test
+    @Ignore
+    public void fuzzPeepTiming() {
+        var fuzzer = new Fuzzer();
+        int max_nid=0;
+        for (int i=0; i<1000000; i++)
+            max_nid = fuzzer.fuzzPeepTiming(i, max_nid);
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/LiteralTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/LiteralTest.java
new file mode 100644
index 00000000..447ef46e
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/LiteralTest.java
@@ -0,0 +1,65 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.type.TypeConAryB;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeMemPtr;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class LiteralTest {
+    private static final String[] ESCAPES = {"\\0", "\\n", "\\t", "\\r", "\\\\", "\\\"", "\\'"};
+    private static final int[] VALUES = {0, 10, 9, 13, 92, 34, 39};
+
+    @Test public void testStringEscapes() {
+        for (int i = 0; i < ESCAPES.length; i++)
+            assertString(ESCAPES[i], new byte[]{(byte)VALUES[i]});
+        assertString("a\\\"b\\\\c\\0d", new byte[]{97, 34, 98, 92, 99, 0, 100});
+        assertString("", new byte[]{});
+        assertString("plain", new byte[]{112, 108, 97, 105, 110});
+    }
+
+    private static void assertString(String text, byte[] expected) {
+        var code = new CodeGen("return \"" + text + "\";").driver(CodeGen.Phase.TypeCheck);
+        TypeMemPtr ptr = (TypeMemPtr)code.expr()._type;
+        TypeConAryB bytes = (TypeConAryB)ptr._obj.field("[]")._t;
+        assertArrayEquals(text, expected, bytes._ary);
+    }
+
+    @Test public void testCharacterEscapes() {
+        for (int i = 0; i < ESCAPES.length; i++)
+            assertCharacter(ESCAPES[i], VALUES[i]);
+        assertCharacter("A", 65);
+    }
+
+    private static void assertCharacter(String text, int expected) {
+        var code = new CodeGen("return '" + text + "';").driver(CodeGen.Phase.TypeCheck);
+        assertEquals(text, expected, ((TypeInteger)code.expr()._type).value());
+    }
+
+    @Test public void testMalformedStrings() {
+        assertBadLiteral("return \"\\q\";", "Unknown string escape");
+        assertBadLiteral("return \"abc", "Unclosed string");
+        assertBadLiteral("return \"abc\\", "Unclosed string");
+        // The quote closes the string at EOF; the missing token is the semicolon.
+        assertBadLiteral("return \"plain\"", ";");
+    }
+
+    @Test public void testMalformedCharacters() {
+        assertBadLiteral("return '\\q';", "Unknown character escape");
+        assertBadLiteral("return '", "Unclosed character");
+        assertBadLiteral("return '\\", "Unclosed character");
+        assertBadLiteral("return '';", "Syntax error");
+        assertBadLiteral("return 'ab';", "Syntax error");
+        assertBadLiteral("return 'a", "Syntax error");
+    }
+
+    private static void assertBadLiteral(String src, String message) {
+        try {
+            new CodeGen(src).parse();
+            fail("Accepted malformed literal: " + src);
+        } catch (Parser.ParseException e) {
+            assertTrue(e.getMessage(), e.getMessage().contains(message));
+        }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Main.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Main.java
new file mode 100644
index 00000000..ca1d0b5b
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Main.java
@@ -0,0 +1,18 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class Main {
+    // Compile and run a simple program
+    public static void main( String[] args ) throws Exception {
+        // First arg is file, 2nd+ args are program args
+        String src = Files.readString(Path.of(args[0]));
+        int arg = Integer.valueOf(args[1]);
+        CodeGen code = new CodeGen(src);
+        code.driver(CodeGen.Phase.LocalSched);
+        System.out.println(code._stop);
+        System.out.println(Eval2.eval(code,arg,100000));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/MemoryEncodingTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/MemoryEncodingTest.java
new file mode 100644
index 00000000..397d644c
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/MemoryEncodingTest.java
@@ -0,0 +1,181 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.codegen.RegAllocTestSupport;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import com.seaofnodes.simple.type.TypeMemPtr;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+// Execution regressions are separate from the fixed spill-measurement cohorts.
+public class MemoryEncodingTest {
+    @Test public void testLoopLoadSearch() {
+        String[] sources = {
+            """
+            u8[] !program=new u8[106]; u8[] !out=new u8[0];
+            int sum=0;
+            for(int i=0; i<arg; i++) {
+                sum+=program#;
+                if(i==1) out=new u8[i+1];
+                else if(i==3) out=new u8[2];
+            }
+            return sum+out#;
+            """,
+            // One possibly aliasing arm must reject the unchanged-memory proof.
+            """
+            struct S { int x; }; !S !a=new S; !S !b=new S;
+            a.x=10; b.x=20; !S !p=a; if(arg&1) p=b;
+            int sum=0;
+            for(int i=0; i<6; i++) {
+                if(i==2) p.x=30;
+                else if(i==4) b.x=40;
+                sum+=a.x;
+            }
+            return sum;
+            """,
+            // Unchanged memory does not imply an unchanged loop-carried pointer.
+            """
+            struct S { int x; }; !S !a=new S; !S !b=new S;
+            a.x=10; b.x=20; !S !p=a; int sum=0;
+            for(int i=0; i<6; i++) {
+                if(i==2) a.x=30;
+                sum+=p.x;
+                p=b; if(i&1) p=a;
+            }
+            return sum;
+            """,
+            // All arms fold, but their values differ: build a value Phi.
+            """
+            struct S { int x; }; !S !a=new S; a.x=1; int sum=0;
+            for(int i=0; i<6; i++) {
+                sum+=a.x;
+                if(i&1) a.x=2;
+                else if(i==2) a.x=3;
+                else a.x=4;
+            }
+            return sum;
+            """
+        };
+        for( int p=0; p<sources.length; p++ ) {
+            CodeGen code=new CodeGen(sources[p]).driver(CodeGen.Phase.FinalizeIR);
+            if( p==0 ) assertNull(code._stop.walk(n ->
+                n instanceof LoadNode ld && ld.ptr() instanceof ProjNode ptr &&
+                ptr.in(0) instanceof NewNode nn &&
+                nn.size()._type==com.seaofnodes.simple.type.TypeInteger.constant(110) ? ld : null));
+            for( int arg=0; arg<7; arg++ ) {
+                long expected=switch(p) {
+                case 0 -> 106*arg+(arg>=2 ? 2 : 0);
+                case 1 -> (arg&1)==0 ? 140 : 60;
+                case 2 -> 130;
+                default -> 16;
+                };
+                assertEquals(Long.toString(expected),Eval2.eval(code,arg));
+            }
+        }
+    }
+
+    private static final String[] SOURCES = {
+        Chapter16Test.CONSTRUCTOR_MEMORY,
+        Chapter18Test.CALL_MEMORY,
+        Chapter18Test.RECURSIVE_MEMORY,
+        Chapter18Test.INLINE_MEMORY,
+        "int[] !a = new int[7]; a[arg]=arg+3; return a[0]+1;",
+        """
+        int[] !a = new int[7];
+        for( int i=0; i<7; i++ ) a[i]=i+arg;
+        for( int i=0; i<6; i++ ) a[i+1]+=a[i];
+        return a[6];
+        """
+    };
+
+    private static long expected(int program, long arg) {
+        return switch(program) {
+        case 0 -> arg==0 ? 111249 : 222351+arg;
+        case 1 -> arg==0 ? 10101325 : 20202322;
+        case 2 -> (10*(arg+1)+arg*(arg+1)/2)*100+10+arg;
+        case 3 -> 400944+arg*10001;
+        case 4 -> arg==0 ? 4 : 1;
+        case 5 -> 21+7*arg;
+        default -> throw new AssertionError();
+        };
+    }
+
+    @Test public void testEmulatedMemory() throws IOException {
+        for( String target : new String[]{"riscv","arm"} )
+            for( int p=0; p<SOURCES.length; p++ ) {
+                CodeGen code = new RegAllocTestSupport.CheckedCodeGen(SOURCES[p]).driver(target,"SystemV",null);
+                int entry=0;
+                for( var n : code._start._outputs )
+                    if( n instanceof FunNode fun && "main".equals(fun._name) )
+                        entry=code._encoding._opStart[fun._nid];
+                for( int arg=0; arg<7; arg++ ) {
+                    byte[] image = new byte[1<<20];
+                    byte[] bits = code._encoding.bits();
+                    System.arraycopy(bits,0,image,0,bits.length);
+                    long result;
+                    if( target.equals("riscv") ) {
+                        EvalRisc5 cpu = new EvalRisc5(image,1<<16);
+                        cpu._pc=entry;
+                        cpu.regs[riscv.A0]=arg;
+                        assertEquals(target+" program "+p+" arg "+arg,0,cpu.step(100000));
+                        result=cpu.regs[riscv.A0];
+                    } else {
+                        EvalArm64 cpu = new EvalArm64(image,1<<16);
+                        cpu._pc=entry;
+                        cpu.regs[arm.X0]=arg;
+                        assertEquals(target+" program "+p+" arg "+arg,0,cpu.step(100000));
+                        result=cpu.regs[arm.X0];
+                    }
+                    assertEquals(target+" program "+p+" arg "+arg,expected(p,arg),result);
+                }
+            }
+    }
+
+    @Test public void testNeverMemory() {
+        // A varying pointer prevents store sinking: the synthetic exit needs both slices.
+        for( String target : new String[]{"x86_64_v2","riscv","arm"} ) {
+            CodeGen code = new CodeGen("""
+                struct S { int x; int y; };
+                !S !a=new S; !S !b=new S; !S !p=a;
+                if( arg ) while( 1 ) { p.x+=arg; p.y+=p.x; p=p==a ? b : a; }
+                return a.x+a.y;
+                """).driver(CodeGen.Phase.LoopTree);
+            assertNotNull(code._stop.walk(n -> {
+                if( n instanceof MemMergeNode mem &&
+                    mem.in(0) instanceof CProjNode exit && exit.in(0) instanceof NeverNode ) {
+                    var fields = ((TypeMemPtr)Parser.TYPES.get("S"))._obj._fields;
+                    assertTrue(mem.alias(fields[0]._alias) instanceof MemPhiNode);
+                    assertTrue(mem.alias(fields[1]._alias) instanceof MemPhiNode);
+                    return mem;
+                }
+                return null;
+            }));
+            code.driver(CodeGen.Phase.RegAlloc,target,"SystemV");
+            RegAllocTestSupport.checkRegisters(code);
+            code.encode();
+        }
+    }
+
+    @Test public void testNativeMemory() throws IOException {
+        Files.createDirectories(Path.of("build/objs"));
+        for( int p=0; p<SOURCES.length; p++ ) {
+            String file="build/objs/memory"+p;
+            StringBuilder c = new StringBuilder("extern long long memory(long long);\nint main() {\n");
+            for( int arg=0; arg<7; arg++ )
+                c.append("if(memory(").append(arg).append(")!=").append(expected(p,arg)).append("LL) return ").append(arg+1).append(";\n");
+            c.append("return 0;\n}\n");
+            Files.writeString(Path.of(file+".c"),c);
+            TestC.run("val memory = { int arg -> "+SOURCES[p]+" };",
+                TestC.CALL_CONVENTION,null,"",file+".c",file,"S","",-1);
+        }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/MergeSortTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/MergeSortTest.java
new file mode 100644
index 00000000..453bd35c
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/MergeSortTest.java
@@ -0,0 +1,85 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import com.seaofnodes.simple.util.SB;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class MergeSortTest {
+
+    @Test public void testMergeSort0() throws IOException {
+        // Test merge sort on a small array of primes
+        String src =
+""" 
+        val merge_sort = { int[] a ->
+            int[] !b = new int[a#];
+            copy_array (a, 0, a#, b);
+            split_merge(a, 0, a#, b);
+        };
+        
+        val split_merge = { int[] !b, int begin, int end, int[] a ->
+            if (end - begin <= 1)
+                return 0;
+            int middle = (end + begin) / 2;
+            split_merge(a, begin, middle, b);
+            split_merge(a, middle, end, b);
+            merge(b, begin, middle, end, a);
+            return 0;
+        };
+        
+        val merge = { int[] !b, int begin, int middle, int end, int[] a ->
+            int i = begin, j = middle;
+        
+            for (int k = begin; k < end; k++) {
+                // && and ||
+                bool cond = false;
+                if (i < middle) {
+                    if (j >= end)          cond = true;
+                    else if (a[i] <= a[j]) cond = true;
+                }
+                if (cond) b[k] = a[i++];
+                else      b[k] = a[j++];
+            }
+        };
+        
+        val copy_array = { int[] !a, int begin, int end, int[] b ->
+            for (int k = begin; k < end; k++)
+                b[k] = a[k];
+        };
+""";
+        int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, };
+        SB sb = new SB().p(primes.length).p("[");
+        for( int prime : primes )
+            sb.p(prime).p(", ");
+        String sprimes = sb.p("]").toString();
+        TestC.run(src, "sort", null, sprimes, 34);
+
+
+        EvalRisc5 R5 = TestRisc5.build("src/test/java/com/seaofnodes/simple/progs",src,  "sort", "merge_sort", 0, 36, false);
+        // Allocate an array of primes, filled in reverse order
+        int ps = R5._heap;
+        R5._heap += (primes.length+1)*8; // 25 primes, and length
+        R5.st4(ps,primes.length);
+        for( int i=0; i<primes.length; i++ )
+            R5.st8(ps+(primes.length-1-i+1)*8,primes[i]);
+        // Pass array base when calling `merge_sort`
+        R5.regs[riscv.A0] = ps;          // Array base to be sorted
+
+        int trap = R5.step(100000);
+        assertEquals(0,trap);
+
+        assertEquals(primes.length,R5.ld4s(ps));
+        for( int i=0; i<primes.length; i++ )
+            assertEquals(primes[i], R5.ld8(ps+(i+1)*8));
+
+        // TODO: replace with ARM Eval
+        Chapter21Test.testCPU(src,"arm", "SystemV",36,null);
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/MutabilityTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/MutabilityTest.java
new file mode 100644
index 00000000..51e31a17
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/MutabilityTest.java
@@ -0,0 +1,73 @@
+package com.seaofnodes.simple;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+import com.seaofnodes.simple.codegen.CodeGen;
+
+public class MutabilityTest {
+    private static void ok(String src, String result) {
+        var code = new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        assertEquals(result,Eval2.eval(code,0));
+    }
+    private static void bad(String src) {
+        try {
+            new CodeGen(src).driver(CodeGen.Phase.TypeCheck);
+        } catch( RuntimeException expected ) {
+            String msg = expected.getMessage();
+            assertTrue("Expected a permission error, got: "+expected,
+                msg!=null && (msg.contains("final") || msg.contains("not of declared type") || msg.contains("Cannot store") || msg.contains("Argument #")));
+            return;
+        }
+        fail("Accepted forbidden write: "+src);
+    }
+
+    @Test public void testIndependentBindingsAndViews() {
+        ok("struct P { int x; }; !P ~p=new P; p.x=7; return p.x;", "7");
+        ok("struct P { int x; }; ~P !p=new P{x=3;}; p=new P{x=7;}; return p.x;", "7");
+        bad("struct P { int x; }; !P ~p=new P; p=new P; return 0;");
+        bad("struct P { int x; }; ~P !p=new P; p.x=7; return 0;");
+        bad("int ~x=3; x=7; return x;");
+        ok("int !x=3; x=7; return x;", "7");
+    }
+
+    @Test public void testDeepViewAndAliases() {
+        ok("struct P { int x; }; !P ~p=new P; ~P ~r=p; p.x=7; return r.x;", "7");
+        bad("struct P { int x; }; struct Box { !P p; }; !P q=new P; Box b=new Box{p=q;}; b.p.x=7; return 0;");
+        bad("struct P { int x; }; P p=new P; !P q=p; q.x=7; return 0;");
+        bad("struct P { P? next; int x; }; !P p=new P{next=new P;}; p.next.x=7; return 0;");
+        bad("struct P { !P? next; int x; }; P p=new P{next=new P;}; p.next.x=7; return 0;");
+    }
+
+    @Test public void testInferencePreservesAccess() {
+        ok("struct P { int x; }; val p=new P; p.x=7; return p.x;", "7");
+        bad("struct P { int x; }; val p=new P; p=new P; return 0;");
+        bad("struct P { int x; }; P p=new P; var q=p; q.x=7; return 0;");
+    }
+
+    @Test public void testParameterPermissions() {
+        ok("struct P { int x; }; val f={ !P p -> p.x=7; return p.x; }; return f(new P);", "7");
+        ok("val f={ int ~x -> return x; }; return f(7);", "7");
+        bad("val f={ int ~x -> x=7; return x; }; return f(3);");
+        bad("struct P { int x; }; val f={ P p -> p.x=7; return p.x; }; return f(new P);");
+        bad("struct P { int x; }; val f={ !P p -> p.x=7; return p.x; }; P p=new P; return f(p);");
+        bad("struct P { int x; }; val f={ P?[] a -> return a#; }; !P?[] a=new !P?[1]; return f(a);");
+    }
+
+    @Test public void testConstructorScope() {
+        ok("struct P { int ~x; }; P p=new P{if(arg) x=3; else x=7;}; return p.x;", "7");
+        bad("int ~outer=1; struct P { int x; }; P p=new P{outer=7;}; return outer;");
+        bad("struct P { int x; }; P p=new P{int ~local=1; local=7;}; return p.x;");
+    }
+
+    @Test public void testArrayLayers() {
+        bad("struct P { int x; }; !P?[] rw=new !P?[1]; P?[] ro=rw; rw[0]=new P; ro[0].x=7; return 0;");
+        ok("u8[] a=new u8[2]; a[0]=7; return a[0];", "7");
+        ok("struct P { int x; }; P?[] a=new P?[1]; a[0]=new P{x=7;}; return a[0].x;", "7");
+        bad("struct P { int x; }; P?[] a=new P?[1]; a[0]=new P; a[0].x=7; return 0;");
+        ok("struct P { int x; }; !P?[] a=new !P?[1]; a[0]=new P; a[0].x=7; return a[0].x;", "7");
+        bad("u8[~] a=new u8[1]; a[0]=7; return 0;");
+        ok("u8[~]?[] rows=new u8[~]?[1]; rows[0]=new u8[1]; return rows#;", "1");
+        bad("u8[~]?[] rows=new u8[~]?[1]; rows[0]=new u8[1]; rows[0][0]=7; return 0;");
+        bad("u8[]?[~] rows=new u8[]?[1]; rows[0]=new u8[1]; return 0;");
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/PhaseTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/PhaseTest.java
new file mode 100644
index 00000000..899f42fe
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/PhaseTest.java
@@ -0,0 +1,56 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.graph.GraphObserver;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.codegen.CodeGen.Phase;
+import com.seaofnodes.simple.node.Node;
+import java.util.ArrayList;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class PhaseTest {
+    private static final String SRC = "int sum=0; for(int i=0; i<arg; i++) sum+=i; return sum;";
+
+    @Test public void testStopAndResume() {
+        ArrayList<String> phases = new ArrayList<>();
+        CodeGen code = new CodeGen(SRC);
+        code._obs = new GraphObserver<Node>() {
+            @Override public void before(Node n) {}
+            @Override public void after(Node n, Node repl, boolean applied) {}
+            @Override public void phase(String phase) { phases.add(phase); }
+        };
+        code.driver(Phase.Iter);
+        assertEquals(Phase.Iter,code._phase);
+        assertEquals("Parse Iter",String.join(" ",phases));
+        code.driver(Phase.TypeCheck);
+        code.driver(Phase.TypeCheck); // Repeated requests do not rerun phases.
+        code.driver(Phase.LoopTree);
+        assertEquals(Phase.LoopTree,code._phase);
+        code.driver(Phase.LocalSched);
+        assertEquals("Parse Iter Opto IterPostOpto FinalizeIR TypeCheck LoopTree Schedule LocalSched",String.join(" ",phases));
+        assertEquals("45",Eval2.eval(code,10));
+    }
+
+    @Test public void testResumeMachineCompilation() {
+        CodeGen staged = new CodeGen(SRC).driver(Phase.TypeCheck);
+        staged.driver(Phase.Select,"x86_64_v2","SystemV");
+        staged.driver(Phase.Encoding,"x86_64_v2","SystemV");
+        byte[] bits = staged._encoding._bits.toByteArray();
+        CodeGen direct = new CodeGen(SRC).driver(Phase.Encoding,"x86_64_v2","SystemV");
+        assertArrayEquals(bits,direct._encoding._bits.toByteArray());
+    }
+
+    @Test public void testOptoRequiresIter() {
+        CodeGen code = new CodeGen(SRC).parse();
+        try {
+            code.opto();
+            fail("Opto must not implicitly run Iter");
+        } catch( AssertionError expected ) {
+            assertEquals("Cannot run Opto after Parse",expected.getMessage());
+        }
+        code.iter().opto();
+        assertEquals(Phase.Opto,code._phase);
+        code.driver(Phase.LocalSched);
+        assertEquals("45",Eval2.eval(code,10));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/SccpTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/SccpTest.java
new file mode 100644
index 00000000..afa0ec58
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/SccpTest.java
@@ -0,0 +1,35 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class SccpTest {
+    @Test public void testLoopFixedPoint() {
+        var code = new CodeGen("int x=1; while(arg) { x=2-x; arg--; } return x;").parse().iter();
+        assertFalse(code.link(code._main).ret().expr()._type.isConstant());
+        code.opto();
+        assertSame(TypeInteger.TRUE,code.link(code._main).ret().expr()._type);
+        code.driver(CodeGen.Phase.LocalSched);
+        assertEquals("1",Eval2.eval(code,4));
+    }
+
+    @Test public void testConservativeCalls() {
+        var code = new CodeGen("val f={ int x -> x+1; }; return f(1)+f(2);").parse().iter().opto();
+        int[] parms = {0};
+        code._start.walk(n -> {
+            if( n instanceof ParmNode p && "x".equals(p._label) ) {
+                parms[0]++;
+                assertSame(TypeInteger.BOT,p._type);
+                assertTrue(p.fun().in(1) instanceof StartNode);
+            }
+            if( n instanceof CallEndNode cend ) assertEquals(1,cend.nIns());
+            return null;
+        });
+        assertEquals(1,parms[0]);
+        code.driver(CodeGen.Phase.LocalSched);
+        assertEquals("5",Eval2.eval(code,0));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/SchedulerTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/SchedulerTest.java
new file mode 100644
index 00000000..6156700d
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/SchedulerTest.java
@@ -0,0 +1,94 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class SchedulerTest {
+
+    @Test public void testMemoryPhiAcrossSiblingBranch() {
+        // The inner memory Phi defines the load's memory. The outer Phi's
+        // other input comes from a branch not dominated by that definition.
+        String src = """
+            struct S { int x; }; !S !a=new S; !S !b=new S;
+            a.x=10; b.x=20; !S !p=a; if(arg>3) p=b;
+            int result=0;
+            if(arg>0) {
+                if(arg>2) p.x=30; else p.x=40;
+                result=a.x;
+            }
+            return result;
+            """;
+        var code = new CodeGen(src).driver(CodeGen.Phase.LocalSched);
+        long[] expected = {0,40,40,30,10,10};
+        for( int arg=0; arg<expected.length; arg++ )
+            assertEquals(Long.toString(expected[arg]),Eval2.eval(code,arg));
+    }
+
+
+    private static void assertObj(Object obj, String name, Object... fields) {
+        assertEquals(Evaluator.Obj.class, obj.getClass());
+        var o = (Evaluator.Obj)obj;
+        assertEquals(name, o.struct()._name);
+        Assert.assertArrayEquals(fields, o.fields());
+    }
+
+    @Test
+    @Ignore
+    public void testJig() {
+        CodeGen code = new CodeGen("""
+struct S {
+    int f;
+}
+!S !v=new S;
+v.f = 2;
+int i=v.f;
+if (arg) v.f=1;
+return i;
+""");
+        code.parse();//.iter().opto().iterPostOpto().finalizeIR();
+        var eval = new Evaluator(code._stop);
+        assertEquals(2L, eval.evaluate(1, 10));
+    }
+
+    @Test
+    public void testStoreInIf() {
+        CodeGen code = new CodeGen("""
+struct S {
+    int f;
+};
+!S !v0=new S;
+if(arg) v0.f=1;
+return v0;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        var eval = new Evaluator(code._stop);
+        assertObj(eval.evaluate(0, 10), "S", 0L);
+        assertObj(eval.evaluate(1, 10), "S", 1L);
+    }
+
+    @Test
+    public void testStoreInIf2() {
+        CodeGen code = new CodeGen("""
+struct S {
+    int f;
+};
+!S !v=new S;
+v.f = 2;
+int i=new S.f;
+i=v.f;
+if (arg) v.f=1;
+return i;
+""");
+        code.driver(CodeGen.Phase.FinalizeIR);
+        var eval = new Evaluator(code._stop);
+        assertEquals(2L, eval.evaluate(0, 10));
+        assertEquals(2L, eval.evaluate(1, 10));
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/Simple.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/Simple.java
new file mode 100644
index 00000000..20d6fe71
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/Simple.java
@@ -0,0 +1,217 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.codegen.CodeGen.Phase;
+import com.seaofnodes.simple.print.*;
+import com.seaofnodes.simple.util.Utils;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Collectors;
+
+public class Simple {
+    public static final String PORTS = "com.seaofnodes.simple.node.cpus";
+
+    static final int DUMP_AFTER_PARSE = 1<<Phase.Parse.ordinal();
+    static final int DUMP_AFTER_ITER = 1<<Phase.Iter.ordinal();
+    static final int DUMP_AFTER_OPTO = 1<<Phase.Opto.ordinal();
+    static final int DUMP_AFTER_ITER_POST_OPTO = 1<<Phase.IterPostOpto.ordinal();
+    static final int DUMP_AFTER_FINALIZE_IR = 1<<Phase.FinalizeIR.ordinal();
+    static final int DUMP_AFTER_TYPE_CHECK = 1<<Phase.TypeCheck.ordinal();
+    static final int DUMP_AFTER_LOOP_TREE = 1<<Phase.LoopTree.ordinal();
+    static final int DUMP_AFTER_SELECT = 1<<Phase.Select.ordinal();
+    static final int DUMP_AFTER_GCM = 1<<Phase.Schedule.ordinal();
+    static final int DUMP_AFTER_LOCAL_SCHED = 1<<Phase.LocalSched.ordinal();
+    static final int DUMP_AFTER_REG_ALLOC = 1<<Phase.RegAlloc.ordinal();
+    static final int DUMP_AFTER_ENCODE = 1<<Phase.Encoding.ordinal();
+
+    static final int DUMP_FINAL              = 1<<16;
+
+    static final int DUMP_PASS_NAME          = 1<<30;
+    static final int DUMP_AFTER_ALL = ((1<<Phase.values().length)-1) | DUMP_PASS_NAME;
+
+    static final int DUMP_DISASSEMBLE        = 1<<31;
+
+    static void usage() {
+        System.out.println(
+"""
+simple [options] <input-file> ...args...
+Options:
+  --dump                   - dump final intermediate representation
+  --dump-after-parse           - dump intermediate representation after parsing
+  --dump-after-iter            - dump intermediate representation after Iter
+  --dump-after-opto            - dump intermediate representation after Opto
+  --dump-after-iter-post-opto  - dump intermediate representation after IterPostOpto
+  --dump-after-finalize-ir     - dump intermediate representation after FinalizeIR
+  --dump-after-type-check      - dump intermediate representation after type checking
+  --dump-after-loop-tree       - dump intermediate representation after loop-tree construction
+  --dump-after-select          - dump intermediate representation after instruction selection
+  --dump-after-gcm             - dump intermediate representation after GCM
+  --dump-after-local-sched     - dump intermediate representation after local scheduling
+  --dump-after-reg-alloc       - dump intermediate representation after register allocation
+  --dump-after-encode          - dump intermediate representation after encoding
+  --dump-after-all             - dump intermediate representation after all passes
+  -S                       - dump generated assembler code
+  --eval                   - evaluate the compiled code in emulator
+  --run                    - run the compiled code natively; this is the default
+  --dump-size              - print the size of generated code
+  --dump-time              - print compilation and execution times
+  --cpu <cpu-name>         - use specific CPU (x86_64_v2, riscv, arm)
+  --abi <abi-name>         - use speific ABI variant (SystemV)
+  --target                 - print native CPU and ABI
+  --version
+  --help
+"""
+);
+        System.exit(0);
+    }
+
+    static void bad_usage() { bad("Invalid usage (use --help)"); }
+    static RuntimeException bad(String err) {
+        System.err.println("ERROR: "+err);
+        System.exit(1);
+        return new RuntimeException(err);
+    }
+
+    static void target() {
+        System.out.print(TestC.CPU_PORT);
+        System.out.print("-");
+        System.out.println(TestC.CALL_CONVENTION);
+    }
+
+    static void dump(CodeGen code, int dump, int pass) {
+        if( (dump & pass)==0 ) return;
+        if( (dump & DUMP_PASS_NAME)!=0 ) System.err.println("Final:");
+        System.err.println(code);
+    }
+
+    static void print_compilation_times(CodeGen code) {
+        long total=0;
+        for( Phase phase : Phase.values() ) {
+            long time=code._times[phase.ordinal()];
+            total+=time;
+            System.out.printf("%-24s %.3f sec%n",phase+" Time:",time/1e3);
+        }
+        System.out.printf("TOTAL COMPILATION TIME:   %.3f sec%n",total/1e3);
+    }
+
+    static String getInput() throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
+            return reader.lines().collect(Collectors.joining("\n"));
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        String input_filename = null;
+        boolean do_eval = false;
+        boolean do_run = true;
+        boolean do_codegen = false;
+        boolean do_print_size = false;
+        boolean do_print_time = false;
+        int dump = 0;
+        int first_arg = 0;
+        String src = null;
+        String cpu = null;
+        String abi = null;
+
+        // Parse command line
+        int i; for( i = 0; i < args.length; i++ ) {
+            String arg = args[i];
+            if( arg.charAt(0) != '-' ) {
+                input_filename = arg;
+                break;
+            }
+
+            switch (arg) {
+            case "-":                         input_filename=""; break;
+            case "--dump":                    dump |= DUMP_FINAL; break;
+            case "--dump-after-parse":          dump |= DUMP_AFTER_PARSE; break;
+            case "--dump-after-finalize-ir":    dump |= DUMP_AFTER_FINALIZE_IR; break;
+            case "--dump-after-iter-post-opto": dump |= DUMP_AFTER_ITER_POST_OPTO; break;
+            case "--dump-after-iter":           dump |= DUMP_AFTER_ITER; break;
+            case "--dump-after-opto":           dump |= DUMP_AFTER_OPTO; break;
+            case "--dump-after-type-check":     dump |= DUMP_AFTER_TYPE_CHECK; break;
+            case "--dump-after-loop-tree":      dump |= DUMP_AFTER_LOOP_TREE; break;
+            case "--dump-after-select":         dump |= DUMP_AFTER_SELECT; break;
+            case "--dump-after-gcm":            dump |= DUMP_AFTER_GCM; break;
+            case "--dump-after-local-sched":    dump |= DUMP_AFTER_LOCAL_SCHED; break;
+            case "--dump-after-reg-alloc":      dump |= DUMP_AFTER_REG_ALLOC; break;
+            case "--dump-after-encode":         dump |= DUMP_AFTER_ENCODE; break;
+            case "--dump-after-all":            dump |= DUMP_AFTER_ALL; break;
+            case "-S":                        dump |= DUMP_DISASSEMBLE; break;
+            case "--eval":                    do_eval = true ; do_run = false; break;
+            case "--run":                     do_run  = true ; break;
+            case "--norun":                   do_run  = false; break;
+            case "--dump-size":               do_print_size = true; break;
+            case "--dump-time":               do_print_time = true; break;
+            case "--cpu":                     if (cpu != null || i + 1 >= args.length || args[i + 1].charAt(0) == '-') bad_usage();
+                                              cpu = args[++i];
+                                              break;
+            case "--abi":                     if (abi != null || i + 1 >= args.length || args[i + 1].charAt(0) == '-') bad_usage();
+                                              abi = args[++i];
+                                              break;
+            case "--target":                  target(); break;
+            case "--version":                 throw Utils.TODO();
+            case "--help":                    usage();
+            default:                          bad_usage();
+            }
+        }
+
+        if (input_filename == null) throw bad("no input file' (use --help)");
+        if( !input_filename.isEmpty() && !input_filename.endsWith(".smp") )
+            throw bad("File extension must be .smp");
+        String base = input_filename.substring(0,input_filename.length()-4);
+
+        if (do_run || (dump & DUMP_DISASSEMBLE) != 0 || do_print_size) {
+            if (cpu == null) cpu = TestC.CPU_PORT;
+            if (abi == null) abi = TestC.CALL_CONVENTION;
+            do_codegen = true;
+        }
+
+        // Read input file
+        try {
+            src = input_filename.isEmpty() ? getInput() : Files.readString(Path.of(input_filename));
+        } catch( IOException e ) { throw bad("Cannot read input file: "+input_filename);  }
+
+        // Compilation pipeline
+        CodeGen code = new CodeGen(src);
+
+        code.driver(do_codegen ? Phase.Encoding : Phase.LocalSched,
+                    do_codegen ? cpu : null, abi, dump);
+        if( do_codegen ) code.exportELF(base+".o");
+
+        dump(code, dump, DUMP_FINAL);
+
+        if (do_codegen && (dump & DUMP_DISASSEMBLE) != 0) {
+            System.out.println(code.asm());
+        }
+
+        if (do_print_size) {
+             System.out.printf( "Code Size: %d%n", code._encoding._bits.size());
+        }
+
+        if (do_print_time) {
+            print_compilation_times(code);
+        }
+
+        if (do_eval) {
+            // TODO: Support for evaluation of functions with different argument numbers and types
+            long t = System.currentTimeMillis();
+            long arg = (i+1 < args.length) ? Integer.parseInt(args[i+1]) : 0;
+            System.out.println(Eval2.eval(code, arg, 100000));
+            if (do_print_time) {
+                System.out.printf( "EXECUTION TIME:             %.3f sec%n",
+                    (System.currentTimeMillis() - t) / 1e3);
+            }
+        }
+        if (do_run) {
+            if ( !TestC.CPU_PORT.equals( cpu ) || !TestC.CALL_CONVENTION.equals( abi ) )
+                throw bad("cannot run code on not native target");
+            String exe = TestC.OS.startsWith("Windows") ? base+".exe" : base;
+            String result = TestC.gcc(base+".o", null, null, true, exe);
+            System.out.print(result);
+        }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/SpillStats.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/SpillStats.java
new file mode 100644
index 00000000..ad044a52
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/SpillStats.java
@@ -0,0 +1,73 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import java.util.Map;
+import java.util.TreeMap;
+import org.junit.runner.*;
+import org.junit.runner.notification.*;
+
+// Run existing tests and sum actual allocations, including ones without goldens.
+// Helpers call record after allocation; ordinary JUnit runs collect nothing.
+public class SpillStats extends RunListener {
+    private static SpillStats ACTIVE;
+    private Description _test;
+    private int _qualityFailures;
+    private final Map<String,long[]> _totals = new TreeMap<>();
+
+    @Override public void testStarted(Description test) { _test = test; }
+    public static void record(CodeGen code, String cohort, String cpu, String abi) {
+        if( ACTIVE==null ) return;
+        String test = ACTIVE._test.getTestClass().getSimpleName()+"."+ACTIVE._test.getMethodName();
+        for( String key : new String[]{cohort+","+cpu+","+abi,cohort+",ALL,ALL"} ) {
+            long[] sum = ACTIVE._totals.computeIfAbsent(key,k -> new long[3]);
+            sum[0]++; sum[1] += code._regAlloc._spills; sum[2] += code._regAlloc._spillScaled;
+        }
+        System.out.println("allocation,"+cohort+","+test+","+cpu+","+abi+","+
+                           code._regAlloc._spills+","+code._regAlloc._spillScaled);
+    }
+
+    // The same native helpers serve old and new program cohorts.
+    public static void recordNative(CodeGen code, String cpu, String abi) {
+        String cohort = ACTIVE!=null && (ACTIVE._test.getTestClass()==Chapter24Test.class || ACTIVE._test.getTestClass()==Chapter24AllocTest.class)
+            ? "Chapter24" : ACTIVE!=null && ACTIVE._test.getTestClass()==Chapter23Test.class
+            ? "Chapter23" : ACTIVE!=null && ACTIVE._test.getTestClass()==Chapter22Test.class
+            ? "Chapter22" : "Chapter21";
+        record(code,cohort,cpu,abi);
+    }
+
+    // Keep running every CPU and native result check when measuring quality.
+    // A changed golden still makes spill-stats fail at the end.
+    public static void checkSpills(int expected, int actual) {
+        if( expected==-1 ) return;
+        try { org.junit.Assert.assertEquals("Expect spills:",expected,actual,Math.max(1,expected>>3)); }
+        catch( AssertionError error ) {
+            if( ACTIVE==null ) throw error;
+            ACTIVE._qualityFailures++;
+            System.err.println(ACTIVE._test+": "+error.getMessage());
+        }
+    }
+
+    public static void main(String[] args) throws ClassNotFoundException {
+        if( args.length==0 ) args = new String[]{"Chapter20Test","Chapter21Test","Chapter21AllocTest","Chapter22Test","Chapter23Test","Chapter23AllocTest","Chapter24Test","Chapter24AllocTest","BrainFuckTest","MergeSortTest"};
+        Class<?>[] tests = new Class<?>[args.length];
+        for( int i=0; i<args.length; i++ )
+            tests[i] = Class.forName("com.seaofnodes.simple."+args[i]);
+        ACTIVE = new SpillStats();
+        JUnitCore junit = new JUnitCore();
+        junit.addListener(ACTIVE);
+        Result result = junit.run(tests);
+        boolean passed = result.wasSuccessful() && ACTIVE._qualityFailures==0;
+        if( !result.wasSuccessful() ) System.out.println("FAILED test run: totals are not a complete comparison.");
+        else if( !passed ) System.out.println("Spill expectations differ; allocation and runtime checks passed.");
+        System.out.println("cohort,cpu,abi,allocations,splits,scaled");
+        for( var row : ACTIVE._totals.entrySet() ) {
+            long[] sum = row.getValue();
+            System.out.println(row.getKey()+","+sum[0]+","+sum[1]+","+sum[2]);
+        }
+        for( Failure failure : result.getFailures() ) System.err.println(failure.getTrace());
+        System.out.println("Tests: "+result.getRunCount()+", failures: "+result.getFailureCount());
+        System.out.println("Spill golden failures: "+ACTIVE._qualityFailures);
+        ACTIVE = null;
+        if( !passed ) System.exit(1);
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/TestArm64.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/TestArm64.java
new file mode 100644
index 00000000..086bf9c7
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/TestArm64.java
@@ -0,0 +1,51 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalArm64;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+
+
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import junit.framework.Assert;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+// Runs 32-bit ARM code in an emulator
+
+public class TestArm64 {
+    public static EvalArm64 build( String file, int arg, int spills, boolean print ) throws IOException {
+        String dir = "src/test/java/com/seaofnodes/simple/progs";
+        String src = Files.readString(Path.of(dir + "/"+file+".smp"));
+        return build(dir,src, file, arg, spills, print);
+    }
+
+    public static EvalArm64 build( String name, String src, int arg, int spills, boolean print ) throws IOException {
+        String dir = "src/test/java/com/seaofnodes/simple/progs";
+        return build(dir, src ,name, arg, spills, print);
+    }
+
+    // Compile and run a simple program
+    public static EvalArm64 build( String dir, String src, String file, int arg, int spills, boolean print ) throws IOException {
+        // Compile and export Simple
+        CodeGen code = new CheckedCodeGen(src).driver("arm", "SystemV",null);
+        SpillStats.recordNative(code,"arm","SystemV");
+        if( print ) { code.print_as_hex(); System.out.print(code.asm()); }
+
+        // Allocation quality not degraded
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+
+        // Image
+        byte[] image = new byte[1<<20]; // A megabyte (1024*1024 bytes)
+        EvalArm64 ARM = new EvalArm64(image, 1<<16);
+        // Code at offset 0
+        System.arraycopy(code._encoding.bits(), 0, image, 0, code._encoding.bits().length);
+        // Initial incoming int arg
+        ARM.regs[arm.X0] = arg;
+        // malloc memory starts at 64K and goes up
+        return ARM;
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/TestC.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/TestC.java
new file mode 100644
index 00000000..3b3aabc0
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/TestC.java
@@ -0,0 +1,137 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.util.Ary;
+import com.seaofnodes.simple.util.Utils;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+import static org.junit.Assert.*;
+
+// Call a C driver program, which calls a Simple-generated .o, and self-checks.
+// Expects GCC from the default CLI, compiles C, compiles Simple, links and runs.
+public abstract class TestC {
+
+    public static final String OS  = System.getProperty("os.name");
+    public static final String CPU = System.getProperty("os.arch");
+
+    public static final String CALL_CONVENTION = OS.startsWith("Windows") ? "Win64" : "SystemV";
+    public static final String CPU_PORT = switch( CPU ) {
+        case "amd64" -> "x86_64_v2";
+        default -> throw Utils.TODO("Map Yer CPU Port Here");
+    };
+
+    public static void run( String file, int spills ) throws IOException { run(file,"",spills); }
+
+    public static void run( String file, String expected, int spills ) throws IOException {
+        run("src/test/java/com/seaofnodes/simple/progs",file,expected,spills);
+    }
+
+    // Compile and run a simple program
+    public static void run( String dir, String file, TypeInteger arg, String expected, int spills, boolean standalone) throws IOException {
+        // Files
+        String  cfile = dir+"/"+file+".c"  ;
+        String  sfile = dir+"/"+file+".smp";
+        String  efile = "build/objs/"+file;
+
+        // Compile and export Simple
+        String src = Files.readString(Path.of(sfile));
+        run(src,CALL_CONVENTION,arg, "",standalone? null: cfile,efile,"S",expected,spills);
+    }
+
+    // link with c and also inline
+    public static void run(String src, String file, TypeInteger arg, String expected, int spills) throws IOException {
+            String dir = "src/test/java/com/seaofnodes/simple/progs";
+            String cfile = dir+"/"+file+".c";
+            String efile = "build/objs/"+file;
+            run(src, CALL_CONVENTION, arg, "", cfile, efile, "S", expected, spills);
+    }
+
+    public static void run(String dir, String file, String expected, int spills ) throws IOException {
+        run(dir, file,null, expected, spills, false);
+    }
+
+    // Do not link with c file - no inline.
+    public static void runS(String file, String expected, int spills ) throws IOException {
+        run("src/test/java/com/seaofnodes/simple/progs", file, null, expected, spills, true);
+    }
+
+
+    // Do not link with c file - just inline with source.
+    public static void runSF(String name, String src, TypeInteger arg, String expected, int spills ) throws IOException {
+        String efile = "build/objs/"+name;
+        run(src,CALL_CONVENTION,arg, "",null,efile,"S",expected,spills);
+    }
+
+    public static void runS(String file, TypeInteger arg, String expected, int spills ) throws IOException {
+        run("src/test/java/com/seaofnodes/simple/progs", file, arg, expected, spills, true);
+    }
+
+
+    public static void run( String src, String simple_conv, TypeInteger arg, String c_conv, String cfile, String efile, String xtn, String expected, int spills ) throws IOException {
+        String bin = efile+xtn;
+        String obj = bin+".o";
+        String exe = OS.startsWith("Windows") ? bin+".exe" : bin;
+        // Compile simple, emit ELF
+        CodeGen code = new CheckedCodeGen(src, arg).driver( CPU_PORT, simple_conv, obj);
+        SpillStats.recordNative(code,CPU_PORT,simple_conv);
+
+        String result = gcc(obj, c_conv, cfile, false, exe );
+        assertEquals(expected,result);
+
+        // Allocation quality not degraded
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+    }
+
+    public static String gcc( String obj, String c_conv, String cfile, boolean stdin, String... args ) throws IOException {
+
+        // Compile the C program.  Compiling code and constants in the low
+        // 2Gig.  Pointers are 64b BUT since always in the low 2G all the
+        // high bits are zero - and Simple code can be emitted treating
+        // pointers as 4bytes.
+        var params = new Ary<>(String.class);
+        params.add("gcc");
+        if( cfile!=null ) params.add(cfile); // Associated C driver, usually has a `main`
+        params.addAll(new String[] {
+                obj,
+                "-lm", // Picks up 'sqrt' for newtonFloat tests to compare
+                "-g",
+                "-o",
+                args[0],
+        });
+        // Calling convention for C calls, if any
+        if( cfile!=null ) {
+            params.add("-D");
+            params.add("CALL_CONV="+c_conv);
+        }
+
+        // Run GCC to link (optionally compile C driver code)
+        Process gcc = new ProcessBuilder(params.asAry()).redirectErrorStream(true).start();
+        int exit;
+        try {
+            boolean normal = gcc.waitFor(2, TimeUnit.SECONDS);
+            exit = normal ? gcc.exitValue() : -1; // no exit???
+        }  catch( InterruptedException e ) {
+            throw new IOException("interrupted");
+        }
+        String result = new String(gcc.getInputStream().readAllBytes());
+        if( exit!=0 ) {
+            System.err.println("gcc error code: "+exit);
+            System.err.println(result);
+        }
+        assertEquals( 0, exit );
+        //assertTrue(result.isEmpty()); // No data in error stream
+
+        // Execute results
+        ProcessBuilder smp = new ProcessBuilder(args);
+        if( stdin ) smp.redirectInput(ProcessBuilder.Redirect.INHERIT);
+        Process p = smp.start();
+        try { exit = p.waitFor(); } catch( InterruptedException e ) { throw new IOException("interrupted"); }
+        result = new String(p.getInputStream().readAllBytes());
+        assertEquals("Program exit status",0,exit);
+        return result;
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/TestRisc5.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/TestRisc5.java
new file mode 100644
index 00000000..f55e7d0b
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/TestRisc5.java
@@ -0,0 +1,57 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.isa.eval.EvalRisc5;
+
+import com.seaofnodes.simple.codegen.RegAllocTestSupport.CheckedCodeGen;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.FunNode;
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.node.cpus.riscv.riscv;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import static org.junit.Assert.*;
+
+// Runs 32-bit R5 code in an emulator
+public abstract class TestRisc5 {
+
+    public static EvalRisc5 build( String file, int arg, int spills, boolean print ) throws IOException {
+        String dir = "src/test/java/com/seaofnodes/simple/progs";
+        String src = Files.readString(Path.of(dir + "/"+file+".smp"));
+        return build(dir,src, file, null, arg, spills, print);
+    }
+
+    public static EvalRisc5 build( String name, String src, int arg, int spills, boolean print ) throws IOException {
+        String dir = "src/test/java/com/seaofnodes/simple/progs";
+        return build(dir, src ,name, null, arg, spills, print);
+    }
+
+    // Compile and run a simple program
+    public static EvalRisc5 build( String dir, String src, String file, String main, int arg, int spills, boolean print ) throws IOException {
+        // Compile and export Simple
+        CodeGen code = new CheckedCodeGen(src).driver("riscv", "SystemV",null);
+        SpillStats.recordNative(code,"riscv","SystemV");
+        if( print ) { code.print_as_hex(); System.out.print(code.asm()); }
+
+        // Allocation quality not degraded
+        SpillStats.checkSpills(spills,code._regAlloc._spillScaled);
+
+        // Image
+        byte[] image = new byte[1<<20]; // A megabyte (1024*1024 bytes)
+        EvalRisc5 R5 = new EvalRisc5(image, 1<<16);
+        // Code at offset 0
+        System.arraycopy(code._encoding.bits(), 0, image, 0, code._encoding.bits().length);
+        // Initial incoming int arg
+        R5.regs[riscv.A0] = arg;
+        // malloc memory starts at 64K and goes up
+
+        // Look up starting PC or zero if not given
+        if( main!=null )
+            for( Node use : code._start._outputs )
+                if( use instanceof FunNode fun && main.equals(fun._name) )
+                    R5._pc = code._encoding._opStart[fun._nid];
+
+        return R5;
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/TypeTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/TypeTest.java
new file mode 100644
index 00000000..fd3fea9d
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/TypeTest.java
@@ -0,0 +1,235 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.type.*;
+import org.junit.Assert;
+import org.junit.Test;
+import static org.junit.Assert.assertSame;
+
+public class TypeTest {
+
+    // Removing zero must not reset the widening history of a remaining range.
+    @Test public void testNonZeroWidening() {
+        for( byte widen=0; widen<=3; widen++ ) {
+            TypeInteger pos = TypeInteger.make(0,255,widen).nonZero();
+            TypeInteger neg = TypeInteger.make(-255,0,widen).nonZero();
+            Assert.assertEquals("positive range widening",widen,pos._widen);
+            Assert.assertEquals("negative range widening",widen,neg._widen);
+            assertSame(TypeInteger.make(1,255,widen),pos);
+            assertSame(TypeInteger.make(-255,-1,widen),neg);
+            // Singleton ranges retain their widening level too.
+            assertSame(TypeInteger.make(1,1,widen),TypeInteger.make(0,1,widen).nonZero());
+            assertSame(TypeInteger.make(-1,-1,widen),TypeInteger.make(-1,0,widen).nonZero());
+        }
+        Assert.assertNull(TypeInteger.ZERO.nonZero());
+    }
+
+    // Struct hashes omit field types, so interning compares unlike leaf kinds.
+    @Test
+    public void testCyclicLeafKinds() {
+        TypeStruct bottom = TypeStruct.make("B14LeafKinds",false,
+                Field.make("x",Type.BOTTOM,2,false, false));
+        TypeStruct one = TypeStruct.make("B14LeafKinds",false,
+                Field.make("x",TypeFloat.constant(1.0),2,false, false));
+        TypeStruct two = TypeStruct.make("B14LeafKinds",false,
+                Field.make("x",TypeFloat.constant(2.0),2,false, false));
+
+        // Meeting creates a new struct while cyclic equality is active. Its
+        // float leaf must compare unequal to the previously interned BOTTOM.
+        TypeStruct meet = (TypeStruct)one.meet(two);
+        assertSame(TypeFloat.F32,meet._fields[0]._t);
+        assertSame(meet,two.meet(one));
+        assertSame(meet,TypeStruct.make("B14LeafKinds",false,
+                Field.make("x",TypeFloat.F32,2,false, false)));
+        assertSame(bottom,meet.meet(bottom));
+        assertSame(meet.dual(),one.dual().join(two.dual()));
+    }
+
+    // Test basic properties and GLB
+    @Test
+    public void testTypeAdHoc() {
+        Assert.assertEquals( Type.BOTTOM, TypeInteger.TRUE.meet(TypeNil.NIL) );
+        Assert.assertEquals( Type.BOTTOM, TypeInteger.TOP .meet(TypeNil.NIL) );
+
+        TypeStruct s1 = TypeStruct.make("s1",false,
+                Field.make("a", TypeInteger.BOT,-1, false, false),
+                Field.make("b", TypeInteger.BOT,-2, false, false) );
+        TypeStruct s2 = TypeStruct.make("s2",false,
+                Field.make("a", TypeInteger.BOT,-3, false, false),
+                Field.make("b", TypeInteger.BOT,-4, false, false) );
+        TypeStruct x1ro = (TypeStruct)s1.makeRO();
+        TypeMemPtr p1 = TypeMemPtr.make(s1);
+        Assert.assertEquals(x1ro, ((TypeMemPtr)p1.glb(false))._obj);
+        Assert.assertNotEquals(s1, s1.dual());
+        TypeStruct s1dglb = ((TypeMemPtr)p1.dual().glb(false))._obj;
+        Assert.assertTrue(x1ro.isa(s1dglb));
+
+        TypeMem m1 = TypeMem.make(2,TypeNil.NIL);
+        TypeMem m2 = TypeMem.make(3,TypeInteger.U16);
+        TypeMem m3 = TypeMem.make(4,TypeFloat.F64);
+        TypeMem m4 = TypeMem.make(5,TypeInteger.BOT);
+
+        Assert.assertNotEquals(m1, m2);
+        Assert.assertNotEquals(m2, m3);
+        Assert.assertNotEquals(m3, m4);
+
+        Assert.assertEquals(TypeStruct.BOT, s1.meet(s2));
+        Assert.assertEquals(TypeMem   .BOT, m1.meet(m2));
+        Assert.assertEquals(TypeMem.make(1,Type.BOTTOM), m1.meet(m3));
+        Assert.assertEquals(TypeMem   .BOT, m3.meet(m4));
+
+        Assert.assertEquals(TypeMem.make(2,Type.BOTTOM), m1.glb(false));
+        Assert.assertEquals(TypeMem.make(2,Type.XNIL), m1.dual());
+        Assert.assertEquals(m4.dual(), m4.glb(false).dual());
+
+        TypeMemPtr ptr1 = TypeMemPtr.make(s1);
+        Assert.assertEquals(s1, ptr1._obj);
+        TypeMemPtr ptr2 = TypeMemPtr.make(s2);
+        Assert.assertEquals(s2, ptr2._obj);
+
+        TypeMemPtr ptr1nil = TypeMemPtr.makeNullable(s1);
+        Assert.assertEquals(s1, ptr1nil._obj);
+        Assert.assertTrue( ptr1nil.nullable() );
+        Assert.assertNotNull( ptr1nil._obj );
+        TypeMemPtr ptr2nil = TypeMemPtr.makeNullable( s2);
+        Assert.assertEquals(s2, ptr2nil._obj);
+
+        Assert.assertNotEquals(ptr1, ptr2);
+        Type p1glb = ptr1.glb(false);
+        Assert.assertNotEquals(ptr1, p1glb );
+        Assert.assertTrue(((TypeMemPtr)p1glb)._ro);
+        Assert.assertTrue(ptr1nil.isa(p1glb));
+
+        Assert.assertEquals(ptr1, ptr1.dual().dual());
+        Assert.assertTrue(p1glb.makeRO().isa( ptr1.dual().glb(false)));
+        Assert.assertEquals(TypeMemPtr.makeNullable(TypeStruct.BOT).withAccess(false), ptr1.meet(ptr2nil));
+        Assert.assertEquals(ptr1nil, ptr1.meet(TypeNil.NIL));
+
+        TypeMemPtr TOP = TypeMemPtr.TOP;
+        TypeMemPtr BOT = TypeMemPtr.makeNullable(TypeStruct.BOT);
+        TypeMemPtr PTR = TypeMemPtr.make(TypeStruct.BOT);
+        Type NULL = TypeNil.NIL;
+        Type PTR_meet_NULL = NULL.meet(PTR);
+        Assert.assertEquals(BOT, PTR_meet_NULL);
+        Type ptr1_meet_ptr2 = ptr1.meet(ptr2);
+        Assert.assertEquals(PTR.withAccess(false), ptr1_meet_ptr2);
+        Type NULL_join_ptr1 = NULL.join(ptr1);
+        Assert.assertEquals(TypePtr.XNPTR, NULL_join_ptr1);
+        Type NULL_join_PTR = PTR.join(NULL);
+        Assert.assertEquals(TypePtr.XNPTR, NULL_join_PTR);
+        Type ptr1_dual = ptr1.dual();
+        Type nullableptr1_dual = ptr1nil.dual();
+
+        // Cyclic check
+        TypeStruct S1 = ((TypeMemPtr)TypeStruct.SFLT2.field("s1")._t)._obj;
+        Assert.assertFalse(s1.isFinal());
+        Type s1ro  = S1.makeRO();
+        Type s1ro2 = S1.makeRO();
+        Assert.assertSame(s1ro,s1ro2);
+        Assert.assertTrue(s1ro.isFinal());
+
+        Assert.assertFalse(S1.isConstant());
+        Type s1glb  = S1.field("s2")._t.glb(false);
+        Type s1glb2 = S1.field("s2")._t.glb(false);
+        Assert.assertSame(s1glb,s1glb2);
+    }
+
+    // Test theoretical properties.
+    // This is a symmetric complete bounded (ranked) lattice.
+    // Also, the meet is commutative and associative.
+    // The lattice has a dual (symmetric), and join is ~(~x meet ~y).
+    // See https://en.wikipedia.org/wiki/Lattice_(order).
+    @Test
+    public void testLatticeTheory() {
+        Type[] ts = Type.gather();
+
+        // Confirm commutative & complete
+        for( Type t0 : ts )
+            for( Type t1 : ts ) {
+                check_commute  (t0,t1);
+                check_symmetric(t0,t1);
+            }
+
+        // Confirm associative
+        for( Type t0 : ts )
+            for( Type t1 : ts )
+                for( Type t2 : ts )
+                    assoc(t0,t1,t2);
+
+        // Confirm symmetry.  If A isa B, then A.join(C) isa B.join(C)
+        for( Type t0 : ts )
+            for( Type t1 : ts )
+                if( t0.isa(t1) )
+                    for( Type t2 : ts ) {
+                        Type t02 = t0.join(t2);
+                        Type t12 = t1.join(t2);
+                        Type mt  = t02.meet(t12);
+                        assertSame(mt,t12);
+                    }
+    }
+
+    // By design in meet, args are already flipped to order _type, which forces
+    // symmetry for things with badly ordered _type fields.  The question is
+    // still interesting for other orders.
+    private static void check_commute( Type t0, Type t1 ) {
+        if( t0==t1 ) return;
+        if( t0.is_simple() && !t1.is_simple() ) return; // By design, flipped the only allowed order
+        Type mta = t0.meet(t1);
+        Type mtb = t1.meet(t0); // Reverse args and try again
+        assertSame(mta,mtb);
+    }
+
+    // A & B = MT
+    // Expect: ~A & ~MT == ~A
+    // Expect: ~B & ~MT == ~B
+    private static void check_symmetric( Type t0, Type t1 ) {
+        if( t1==t0 ) return;
+        Type mt = t0.meet(t1);
+        Type dm = mt.dual();
+        Type d0 = t0.dual();
+        Type d1 = t1.dual();
+        Type ta = dm.meet(d1);
+        Type tb = dm.meet(d0);
+        assertSame(ta,d1);
+        assertSame(tb,d0);
+    }
+
+    private static void assoc( Type t0, Type t1, Type t2 ) {
+        Type t01   = t0 .meet(t1 );
+        Type t12   = t1 .meet(t2 );
+        Type t01_2 = t01.meet(t2 );
+        Type t0_12 = t0 .meet(t12);
+        assertSame(t01_2,t0_12);
+    }
+
+    // Test cyclic types and meets
+    @Test
+    public void testCyclic0() {
+        Type d0 = TypeStruct.SFLT2.dual();
+        Type d1 = d0.dual();
+        assertSame(TypeStruct.SFLT2,d1);
+    }
+
+    @Test
+    public void testGLB() {
+        Type[] ts = Type.gather();
+        for( Type t0 : ts )
+            if( !(t0 instanceof Field || t0 instanceof TypeStruct || t0 instanceof TypeTuple || t0 instanceof TypeConAry ) )
+                Assert.assertTrue(t0.isa(t0.glb(false)));
+    }
+
+    @Test
+    public void testList() {
+        TypeStruct list = TypeStruct.open("List");
+        TypeMemPtr plist = TypeMemPtr.makeNullable(list);
+        list = list.add(Field.make("next", plist, 2, false, false ) );
+        list = list.add(Field.make("x", TypeInteger.BOT, 3, false, false));
+        // Make a cyclic type
+        list = list.close();
+        // Fields are mutable
+        Assert.assertFalse(list.isFinal());
+        TypeStruct flist = (TypeStruct)list.makeRO();
+        Assert.assertTrue(flist.isFinal());
+        Assert.assertNotSame( list, flist );
+
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/FlagSpillTestSupport.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/FlagSpillTestSupport.java
new file mode 100644
index 00000000..00d86c63
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/FlagSpillTestSupport.java
@@ -0,0 +1,145 @@
+package com.seaofnodes.simple.codegen;
+
+import com.seaofnodes.isa.X86;
+import com.seaofnodes.isa.eval.EvalArm64;
+import com.seaofnodes.simple.TestC;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.node.cpus.arm.arm;
+import com.seaofnodes.simple.node.cpus.x86_64_v2.x86_64_v2;
+import com.seaofnodes.simple.type.TypeInteger;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import static org.junit.Assert.*;
+
+// Force overlapping flags, then force every GPR unavailable across the gap.
+public class FlagSpillTestSupport {
+    private static class Op extends MachConcreteNode {
+        final RegMask _def, _use, _kill;
+        Op(RegMask def,RegMask use,RegMask kill,Node... ins) {
+            super(ins); _def=def; _use=use; _kill=kill; _type=TypeInteger.BOT;
+        }
+        @Override public String op() { return "flagsProbe"; }
+        @Override public RegMask outregmap() { return _def; }
+        @Override public RegMask regmap(int i) { return _use; }
+        @Override public RegMask killmap() { return _kill; }
+        @Override public void encoding(Encoding enc) { throw new AssertionError(); }
+    }
+
+    public static void run() throws Exception {
+        StringBuilder asm = new StringBuilder(".text\n");
+        for( boolean isArm : new boolean[]{false,true} )
+            for( boolean stack : new boolean[]{false,true} ) {
+                CodeGen code = new CodeGen("");
+                code._callingConv="SystemV";
+                code._mach=isArm ? new arm(code) : new x86_64_v2(code);
+                RegionNode block = new RegionNode(null,code._start,code._start);
+                code._cfg.add(block);
+                int flagsReg=isArm ? 64 : 32, firstStack=flagsReg+1;
+                RegMask flags = new RegMask(flagsReg);
+                Op def = new Op(flags,null,null,block);
+                RegMask killMask = stack ? (isArm ? new RegMask(0x7fffffffL,1L) : new RegMask(0x1ffffffefL)) : flags;
+                Op kill = new Op(null,null,killMask,block);
+                new Op(null,flags,null,block,def);
+                RegAlloc alloc = new RegAlloc(code);
+                alloc.regAlloc();
+
+                int splits=0, slots=0;
+                for( Node n : block._outputs ) if( n instanceof SplitNode split ) {
+                    int dst=alloc.regnum(n), src=alloc.regnum(n.in(1));
+                    assertTrue(split.outregmap().test(dst));
+                    assertTrue(split.regmap(1).test(src));
+                    for( int fp=isArm ? 32 : 16; fp<flagsReg; fp++ ) {
+                        assertFalse("FP output allowed",split.outregmap().test(fp));
+                        assertFalse("FP input allowed",split.regmap(1).test(fp));
+                    }
+                    if( dst>=firstStack || src>=firstStack ) slots++;
+                    splits++;
+                }
+                assertTrue(splits>=2);
+                assertEquals(stack,slots!=0);
+
+                code._regAlloc=alloc;
+                FunNode frame = new FunNode(null,null,"flags",(Node)null);
+                Encoding save = new Encoding(code), restore = new Encoding(code);
+                save._fun=restore._fun=frame;
+                Encoding enc = save;
+                for( Node n : block._outputs ) {
+                    if( n==kill ) enc=restore;
+                    if( n instanceof SplitNode split ) split.encoding(enc);
+                }
+                if( isArm ) {
+                    for( int bits=0; bits<16; bits++ ) {
+                        EvalArm64 cpu = new EvalArm64(new byte[1024],512);
+                        System.arraycopy(save._bits.buf(),0,cpu._buf,0,save._bits.size());
+                        System.arraycopy(restore._bits.buf(),0,cpu._buf,save._bits.size(),restore._bits.size());
+                        cpu.N=(bits&8)!=0; cpu.Z=(bits&4)!=0; cpu.C=(bits&2)!=0; cpu.V=(bits&1)!=0;
+                        assertEquals(0,cpu.step(save._bits.size()/4));
+                        cpu.N=cpu.Z=cpu.C=cpu.V=false;
+                        if( stack ) for( int r=0; r<31; r++ ) cpu.regs[r]=0;
+                        assertEquals(0,cpu.step(restore._bits.size()/4));
+                        assertEquals((bits&8)!=0,cpu.N); assertEquals((bits&4)!=0,cpu.Z);
+                        assertEquals((bits&2)!=0,cpu.C); assertEquals((bits&1)!=0,cpu.V);
+                        assertEquals(512,cpu.regs[31]);
+                    }
+                } else {
+                    Encoding body = new Encoding(code);
+                    int[] preserved={3,5,6,7,12,13,14,15};
+                    for( int r : preserved ) pushPop(body,r,false);
+                    X86.imm(body,0x81,5,4,16); // Reserve spill storage.
+                    X86.flags(body,TestC.OS.startsWith("Windows") ? 1 : 7,true);
+                    bytes(body,save);
+                    if( stack ) {
+                        for( int r=0; r<16; r++ ) if( r!=4 ) X86.constant(body,r,0);
+                    } else X86.reg(body,0x39,0,0); // CMP rax,rax clobbers only flags.
+                    bytes(body,restore);
+                    X86.flags(body,0,false); // Return the restored flags.
+                    X86.imm(body,0x81,0,4,16);
+                    for( int i=preserved.length-1; i>=0; i-- ) pushPop(body,preserved[i],true);
+                    X86.ret(body);
+                    String name=stack ? "flags_stack" : "flags_reg";
+                    asm.append(".globl ").append(name).append('\n').append(name).append(":\n.byte ");
+                    for( int i=0; i<body._bits.size(); i++ ) {
+                        if( i!=0 ) asm.append(',');
+                        asm.append(body._bits.buf()[i]&255);
+                    }
+                    asm.append('\n');
+                }
+            }
+        Path dir=Files.createTempDirectory(Path.of("build/objs"),"flag_spills_");
+        Files.writeString(dir.resolve("flags.s"),asm);
+        Files.writeString(dir.resolve("flags.c"),"""
+            typedef unsigned long long u64;
+            u64 __attribute__((CALL_CONV)) flags_reg(u64);
+            u64 __attribute__((CALL_CONV)) flags_stack(u64);
+            int main(void) {
+                const int positions[]={0,2,4,6,7,11};
+                for(int bits=0; bits<64; bits++) {
+                    u64 flags=0x202;
+                    for(int i=0;i<6;i++) if(bits&(1<<i)) flags|=1ULL<<positions[i];
+                    if((flags_reg(flags)&0x8d5)!=(flags&0x8d5)) return 1;
+                    if((flags_stack(flags)&0x8d5)!=(flags&0x8d5)) return 2;
+                }
+                return 0;
+            }
+            """);
+        String exe=dir.resolve(TestC.OS.startsWith("Windows") ? "flags.exe" : "flags").toString();
+        exec("gcc","-DCALL_CONV="+(TestC.OS.startsWith("Windows") ? "ms_abi" : "sysv_abi"),
+            "-o",exe,dir.resolve("flags.c").toString(),dir.resolve("flags.s").toString());
+        exec(exe);
+    }
+
+    private static void exec(String... command) throws Exception {
+        Process process = new ProcessBuilder(command).redirectErrorStream(true).start();
+        String output = new String(process.getInputStream().readAllBytes(),java.nio.charset.StandardCharsets.UTF_8);
+        assertEquals(String.join(" ",command)+"\n"+output,0,process.waitFor());
+    }
+
+    private static void bytes(Encoding dst,Encoding src) {
+        for( int i=0; i<src._bits.size(); i++ ) dst.add1(src._bits.buf()[i]&255);
+    }
+    private static void pushPop(Encoding enc,int reg,boolean pop) {
+        if( reg>=8 ) enc.add1(0x41);
+        enc.add1((pop ? 0x58 : 0x50)+(reg&7));
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java
new file mode 100644
index 00000000..b9b49c9f
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/PrintRegTestSupport.java
@@ -0,0 +1,26 @@
+package com.seaofnodes.simple.codegen;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import static org.junit.Assert.*;
+public class PrintRegTestSupport {
+    public static void check() throws Exception {
+        var code = new CodeGen("return 0;").parse();
+        var alloc = new RegAlloc(code);
+        var n = new ConstantNode(TypeInteger.ZERO);
+        var a = new LRG((short)1);
+        var b = new LRG((short)2);
+        var c = new LRG((short)3);
+        a._reg = -1;
+        c._leader = b;
+        b._leader = a;
+        var field = RegAlloc.class.getDeclaredField("_lrgs");
+        field.setAccessible(true);
+        var map = (java.util.Map<Node,LRG>)field.get(alloc);
+        map.put(n,c);
+        assertEquals("V1",alloc.reg(n));
+        assertEquals(-1,alloc.regnum(n));
+        assertSame(c,map.get(n));
+        assertSame(b,c._leader);
+        assertSame(a,b._leader);
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/RegAllocTestSupport.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/RegAllocTestSupport.java
new file mode 100644
index 00000000..0304c6a1
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/RegAllocTestSupport.java
@@ -0,0 +1,346 @@
+package com.seaofnodes.simple.codegen;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.node.cpus.x86_64_v2.x86_64_v2;
+import com.seaofnodes.simple.type.TypeInteger;
+import static org.junit.Assert.*;
+
+// Small scheduled machine graphs isolate register constraints from peepholes.
+public class RegAllocTestSupport {
+    private static final RegMask A = new RegMask(0), B = new RegMask(1);
+    private static class Op extends MachConcreteNode {
+        final RegMask _def, _use, _kill;
+        final boolean _clone;
+        Op(RegMask def, RegMask use, RegMask kill, boolean clone, Node... ins) {
+            super(ins); _def=def; _use=use; _kill=kill; _clone=clone; _type=TypeInteger.BOT;
+        }
+        @Override public String op() { return "testOp"; }
+        @Override public RegMask outregmap() { return _def; }
+        @Override public RegMask regmap(int i) { return _use; }
+        @Override public RegMask killmap() { return _kill; }
+        @Override public boolean isClone() { return _clone; }
+        @Override public Node copy() { return new Op(_def,_use,_kill,_clone,(Node)null); }
+        @Override public void encoding(Encoding enc) { throw new AssertionError(); }
+    }
+    private static SplitNode testSplit(CodeGen code, MachNode def) {
+        LRG lrg = new LRG((short)0);
+        lrg._machDef = def;
+        return code._mach.split("test",(byte)0,lrg);
+    }
+    private static CodeGen graph() {
+        CodeGen code = new CodeGen("");
+        code._mach = new x86_64_v2(code);
+        code._cfg.add(code._start);
+        return code;
+    }
+
+    public static void uncoloredFixedNeighbor() throws Exception {
+        CodeGen code = graph();
+        RegAlloc alloc = new RegAlloc(code);
+        Op def = new Op(new RegMask(3L),null,null,false,code._start);
+        LRG lrg = alloc.newLRG(def);
+        LRG neighbor = new LRG((short)99);
+        neighbor._mask = A;
+        lrg.addNeighbor(neighbor); // Uncolored, but its only possible color is A.
+        var bias = IFG.class.getDeclaredMethod("biasColorNeighbors",RegAlloc.class,Node.class,RegMask.class);
+        bias.setAccessible(true);
+        assertEquals((short)1,bias.invoke(null,alloc,def,new RegMaskRW(3L,0L)));
+    }
+
+    public static void masks() {
+        for( int reg : new int[]{0,63,64,65,127} ) {
+            RegMask mask = new RegMask(reg);
+            assertEquals(reg,mask.firstReg());
+            assertEquals(1,mask.size());
+        }
+        assertEquals(-1,new RegMask(0L).firstReg());
+        assertFalse(new RegMask(0L).size1());
+        RegMask boundary = new RegMask(Long.MIN_VALUE,Long.MIN_VALUE|1);
+        assertEquals(64,boundary.nextReg((short)63));
+        assertEquals(127,boundary.nextReg((short)64));
+        assertEquals(-1,boundary.nextReg((short)127));
+    }
+
+    public static void union() {
+        CodeGen code = graph();
+        Op use = new Op(null,B,null,false,code._start);
+        LRG a = new LRG((short)1), b = new LRG((short)2);
+        a._mask = new RegMask(3L);
+        b._mask = new RegMask(6L);
+        b.machUse(use,(short)2,true);
+        LRG both = a.union(b);
+        assertNotNull(both._mask);
+        assertEquals(1,both._mask.firstReg());
+        assertEquals(1,both._mask.size());
+        assertSame(use,both._machUse);
+        assertEquals(2,both._uidx);
+    }
+
+    public static void killWithoutResult() {
+        CodeGen code = graph();
+        Op def = new Op(A,null,null,false,code._start);
+        new Op(null,null,A,false,code._start); // Clobbers A, produces no value.
+        new Op(null,A,null,false,code._start,def);
+        RegAlloc alloc = new RegAlloc(code);
+        assertTrue(BuildLRG.run(0,alloc));
+        assertFalse("A live value cannot survive a register kill",IFG.build(0,alloc));
+    }
+
+    public static void nullUseMask() {
+        CodeGen code = graph();
+        Op def = new Op(A,null,null,false,code._start);
+        new Op(null,null,null,false,code._start,def); // Scheduling dependency only.
+        RegAlloc alloc = new RegAlloc(code);
+        assertTrue(BuildLRG.run(0,alloc));
+        assertTrue(IFG.build(0,alloc));
+    }
+
+    public static void cloneRegisterClass() {
+        for( RegMask required : new RegMask[]{B,new RegMask(6L)} ) {
+            CodeGen code = graph();
+            Op def = new Op(A,null,null,true,code._start);
+            Op use = new Op(null,required,null,false,code._start,def);
+            Op use2 = new Op(null,required,null,false,code._start,def);
+            RegAlloc alloc = new RegAlloc(code);
+            alloc.regAlloc(); // Re-cloning an A-only value cannot satisfy B/C uses.
+            assertEquals(0,alloc.regnum(def));
+            assertTrue(required.test(alloc.regnum(use.in(1))));
+            assertTrue(required.test(alloc.regnum(use2.in(1))));
+            assertTrue(use.in(1) instanceof SplitNode);
+        }
+    }
+
+    public static void commutativePhi() {
+        CodeGen code = graph();
+        Op a = new Op(A,null,null,false,code._start);
+        Op b = new Op(A,null,null,false,code._start);
+        Op add = new Op(A,A,null,false,code._start,a,b) {
+            @Override public boolean commutes() { return true; }
+        };
+        RegionNode region = new RegionNode(null,code._start,code._start);
+        new PhiNode("sum",TypeInteger.BOT,region,add,a);
+        code._cfg.add(region);
+        assertTrue(BuildLRG.run(0,new RegAlloc(code)));
+    }
+
+    private static class CallOp extends CallNode implements MachNode {
+        CallOp(Node ctrl, Node def) { super(null,ctrl,null,def,def); }
+        @Override public RegMask regmap(int i) { return i==2 ? A : i==3 ? B : null; }
+        @Override public RegMask outregmap() { return null; }
+        @Override public void encoding(Encoding enc) { throw new AssertionError(); }
+    }
+
+    public static void popularUses() {
+        for( int calls=0; calls<=2; calls++ ) {
+            CodeGen code = graph();
+            RegAlloc alloc = new RegAlloc(code);
+            RegionNode block = new RegionNode(null,code._start,code._start);
+            Op def = new Op(new RegMask(7L),null,null,false,block);
+            LRG lrg = alloc.newLRG(def);
+            lrg._machDef = def;
+            lrg._mask = new RegMask(0L);
+            Op ab = new Op(null,new RegMask(3L),null,false,block,def);
+            Op bc = new Op(null,new RegMask(6L),null,false,block,def);
+            Op a = new Op(null,A,null,false,block,def,def);
+            Op b = new Op(null,B,null,false,block,def);
+            Op dep = new Op(null,null,null,false,block,def);
+            CallOp call = calls>0 ? new CallOp(block,def) : null;
+            if( calls==2 ) new CallOp(block,def);
+            boolean split = alloc.splitEmptyMaskByUse((byte)0,lrg);
+            assertEquals(calls<2,split);
+            if( !split ) { assertSame(def,a.in(1)); assertSame(def,b.in(1)); continue; }
+            // Two shared copies, even with overlapping masks and repeated inputs.
+            assertTrue(a.in(1) instanceof SplitNode);
+            assertTrue(b.in(1) instanceof SplitNode);
+            assertNotSame(a.in(1),b.in(1));
+            assertSame(a.in(1),a.in(2));
+            assertSame(b.in(1),ab.in(1));
+            assertSame(b.in(1),bc.in(1));
+            assertSame(def,dep.in(1)); // A scheduling dependency has no register.
+            assertEquals(3,def.nOuts()); // Two copies and the dependency.
+            if( call!=null ) {
+                assertSame(a.in(1),call.in(2));
+                assertSame(b.in(1),call.in(3));
+            }
+        }
+    }
+
+    // Check the scheduled graph before encoding adds untyped branches or rewrites tail calls.
+    public static class CheckedCodeGen extends CodeGen {
+        public CheckedCodeGen(String src) { super(src); }
+        public CheckedCodeGen(String src, TypeInteger arg) { super(src,arg); }
+        @Override public CodeGen regAlloc() {
+            super.regAlloc();
+            checkRegisters(this);
+            return this;
+        }
+    }
+
+    public static void topPhi() {
+        // Either arm can be the synthetic exit.  Both predecessors share a
+        // block here so making TOP live would conflict with the real value.
+        for( int slot=1; slot<=2; slot++ ) {
+            CodeGen code = graph();
+            RegAlloc alloc = new RegAlloc(code);
+            Op def = new Op(A,null,null,false,code._start);
+            Node top = new ConstantNode(com.seaofnodes.simple.type.Type.TOP);
+            RegionNode region = new RegionNode(null,code._start,code._start);
+            PhiNode phi = new PhiNode("value",TypeInteger.BOT,region,slot==1 ? top : def,slot==2 ? top : def);
+            phi._type = TypeInteger.BOT;
+            new Op(null,A,null,false,region,phi);
+            code._cfg.add(region);
+            assertTrue(BuildLRG.run(0,alloc));
+            assertNull(alloc.lrg(top));
+            assertSame(alloc.lrg(def),alloc.lrg(phi));
+            assertTrue(IFG.build(0,alloc));
+            alloc.insertBefore(phi,slot,"test",(byte)0,alloc.lrg(phi));
+            assertSame(top,phi.in(slot));
+        }
+    }
+
+    public static void checkRegisters(CodeGen code) {
+        assertTrue(code._regAlloc.verifyFunctionLocalEdges());
+        for( CFGNode bb : code._cfg )
+            for( Node n : bb._outputs ) {
+                if( n instanceof MachNode mach ) {
+                    if( code._regAlloc.regnum(n)>=0 && mach.outregmap()!=null )
+                        assertTrue(n.getClass().getSimpleName()+"#"+n._nid,code._regAlloc.regnum(n)>=0 && mach.outregmap().test(code._regAlloc.regnum(n)));
+                    for( int i=n instanceof ParmNode ? 2 : 1; i<n.nIns(); i++ )
+                        if( n.in(i)!=null && code._regAlloc.regnum(n.in(i))>=0 && mach.regmap(i)!=null )
+                            assertTrue(n.getClass().getSimpleName()+"#"+n._nid+" input "+i,code._regAlloc.regnum(n.in(i))>=0 && mach.regmap(i).test(code._regAlloc.regnum(n.in(i))));
+                    if( mach.twoAddress()!=0 )
+                        assertEquals(code._regAlloc.regnum(n),code._regAlloc.regnum(n.in(mach.twoAddress())));
+                }
+                if( n instanceof PhiNode && code._regAlloc.regnum(n)>=0 )
+                    for( int i=n instanceof ParmNode ? 2 : 1; i<n.nIns(); i++ )
+                        if( n.in(i)._type==com.seaofnodes.simple.type.Type.TOP )
+                            assertNull(code._regAlloc.lrg(n.in(i)));
+                        else
+                            assertEquals(code._regAlloc.regnum(n),code._regAlloc.regnum(n.in(i)));
+            }
+    }
+
+    public static void copyClobber() throws Exception {
+        for( boolean killed : new boolean[]{false,true} ) {
+            CodeGen code = graph();
+            RegAlloc alloc = new RegAlloc(code);
+            Op def = new Op(A,null,null,false,code._start);
+            alloc.newLRG(def)._reg=0;
+            SplitNode hi = testSplit(code,def);
+            hi.setDef(0,code._start); hi.setDef(1,def);
+            alloc.newLRG(hi)._reg=1;
+            new Op(null,null,killed ? A : null,false,code._start);
+            SplitNode lo = testSplit(code,hi);
+            lo.setDef(0,code._start); lo.setDef(1,hi);
+            alloc.newLRG(lo)._reg=0;
+            Op use = new Op(null,A,null,false,code._start,lo);
+            var post = RegAlloc.class.getDeclaredMethod("postColor");
+            post.setAccessible(true); post.invoke(alloc);
+            assertSame(killed ? lo : def,use.in(1));
+        }
+        CodeGen pre = graph();
+        RegAlloc uncolored = new RegAlloc(pre);
+        Op def0 = new Op(A,null,null,false,pre._start);
+        uncolored.newLRG(def0)._mask=A;
+        Op fixed = new Op(A,null,null,false,pre._start);
+        uncolored.newLRG(fixed)._mask=A;
+        SplitNode copy = testSplit(pre,def0);
+        copy.setDef(0,pre._start); copy.setDef(1,def0);
+        assertFalse("A fixed definition clobbers even before coloring",uncolored.sameBlockNoClobber(copy));
+    }
+
+    public static void coldLoopSelfConflict() {
+        for( boolean phiConflict : new boolean[]{false,true} ) {
+            CodeGen code = graph();
+            RegAlloc alloc = new RegAlloc(code);
+            Op init = new Op(A,null,null,false,code._start);
+            LoopNode loop = new LoopNode(null,code._start);
+            PhiNode phi = new PhiNode("loop",TypeInteger.BOT,loop,init,null);
+            Op back = new Op(A,A,null,false,loop,phi);
+            phi.setDef(2,back);
+            Op use = new Op(null,A,null,false,loop,phi);
+            loop.setDef(2,loop);
+            LRG lrg = alloc.newLRG(phi);
+            lrg._mask = A;
+            alloc.union(lrg,init); alloc.union(lrg,back);
+            lrg.selfConflict(back);
+            if( phiConflict ) lrg.selfConflict(phi);
+            assertTrue(alloc.splitSelfConflict((byte)0,lrg));
+            assertSame(phi,use.in(1)); // First try leaves the hot definition alone.
+            assertSame(back,phi.in(2));
+            if( phiConflict ) assertTrue(phi.in(1) instanceof SplitNode);
+            // Even if the first attempt made no graph change, retry must split.
+            assertTrue(alloc.splitSelfConflict((byte)1,lrg));
+            assertTrue(phi.in(2) instanceof SplitNode);
+            if( phiConflict ) assertTrue(use.in(1) instanceof SplitNode);
+        }
+    }
+
+    public static void copyForward() throws Exception {
+        // Forwarding, fixed operand, two-address tie, intervening clobber,
+        // another user, and a scheduling-only edge.
+        for( int kind=0; kind<6; kind++ ) {
+            CodeGen code = graph();
+            RegAlloc alloc = new RegAlloc(code);
+            Op def = new Op(A,null,null,false,code._start);
+            alloc.newLRG(def)._reg=0;
+            SplitNode copy = testSplit(code,def);
+            copy.setDef(0,code._start); copy.setDef(1,def);
+            alloc.newLRG(copy)._reg=1;
+            if( kind==3 ) new Op(null,null,A,false,code._start);
+            int twoAddress = kind==2 ? 1 : 0;
+            RegMask mask = kind==1 ? B : kind==5 ? null : new RegMask(3L);
+            Op use = new Op(null,mask,null,false,code._start,copy) {
+                @Override public int twoAddress() { return twoAddress; }
+            };
+            if( kind==4 ) new Op(null,B,null,false,code._start,copy);
+            var post = RegAlloc.class.getDeclaredMethod("postColor");
+            post.setAccessible(true); post.invoke(alloc);
+            assertSame("copy case "+kind,kind==0 ? def : copy,use.in(1));
+            assertEquals(kind==0 ? 0 : 1,alloc._spills);
+        }
+    }
+
+    public static void coalescing() {
+        // Merge, incompatible masks, interference, capacity, and adjacency remapping.
+        for( int kind=0; kind<5; kind++ ) {
+            CodeGen code = graph();
+            RegAlloc alloc = new RegAlloc(code);
+            Op def = new Op(new RegMask(3L),null,null,false,code._start);
+            SplitNode copy = testSplit(code,def);
+            copy.setDef(0,code._start); copy.setDef(1,def);
+            Op use = new Op(null,new RegMask(3L),null,false,code._start,copy);
+            LRG from = alloc.newLRG(def), to = alloc.newLRG(copy);
+            from._mask = kind==1 ? A : new RegMask(3L);
+            to._mask = kind==1 ? B : new RegMask(3L);
+            from.machDef(def,false); from.machUse(copy,(short)1,false);
+            to.machDef(copy,false); to.machUse(use,(short)1,false);
+            LRG left = new LRG((short)100), right = new LRG((short)101);
+            if( kind==2 ) { from.addNeighbor(to); to.addNeighbor(from); }
+            if( kind>=3 ) {
+                from.addNeighbor(left); left.addNeighbor(from);
+                if( kind==3 ) { to.addNeighbor(right); right.addNeighbor(to); }
+                else { to.addNeighbor(left); left.addNeighbor(to); }
+            }
+            int fcnt=from.nadj(), tcnt=to.nadj();
+            assertTrue(Coalesce.coalesce(0,alloc));
+            if( kind==0 || kind==4 ) {
+                assertSame(def,use.in(1));
+                assertSame(alloc.lrg(def),alloc.lrg(copy));
+                assertSame(use,alloc.lrg(def)._machUse);
+                assertEquals(1,alloc.lrg(def)._uidx);
+                if( kind==4 ) {
+                    assertEquals(1,left.nadj());
+                    assertSame(alloc.lrg(def),left._adj.at(0));
+                    assertSame(left,alloc.lrg(def)._adj.at(0));
+                }
+            } else {
+                assertSame(copy,use.in(1));
+                assertNotSame(alloc.lrg(def),alloc.lrg(copy));
+                assertEquals(fcnt,from.nadj());
+                assertEquals(tcnt,to.nadj());
+            }
+        }
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/X86EncodingTest.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/X86EncodingTest.java
new file mode 100644
index 00000000..0914d916
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/codegen/X86EncodingTest.java
@@ -0,0 +1,123 @@
+package com.seaofnodes.simple.codegen;
+
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.node.cpus.x86_64_v2.CmpMemX86;
+import com.seaofnodes.simple.node.cpus.x86_64_v2.NotX86;
+import com.seaofnodes.simple.node.cpus.x86_64_v2.MulIX86;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class X86EncodingTest {
+
+    @Test
+    public void testLogicalNotRegisters() {
+        CodeGen code = new CodeGen("return !arg;")
+            .driver(CodeGen.Phase.Select, "x86_64_v2", "SystemV");
+        var not = code._stop.walk(n -> n instanceof NotX86 ? (NotX86)n : null);
+        assertNotNull("Must exercise logical not", not);
+        int[][] registers = {{0,0}, {1,1}, {7,7}, {9,9}, {1,9}, {9,1}, {6,0}, {15,8}};
+        // TEST src,src; SETZ dstb; MOVZX dst32,dstb. Include overlapping
+        // registers, low-byte registers requiring REX, and extended registers.
+        String[] expected = {
+            "4885c00f94c00fb6c0", "4885c90f94c10fb6c9",
+            "4885ff400f94c7400fb6ff", "4d85c9410f94c1450fb6c9",
+            "4d85c90f94c10fb6c9", "4885c9410f94c1450fb6c9",
+            "4885c0400f94c6400fb6f6", "4d85c0410f94c7450fb6ff"
+        };
+        for (int i = 0; i < registers.length; i++) {
+            int dst = registers[i][0], src = registers[i][1];
+            var enc = new FixedRegisterEncoding(code, not, dst, not.in(1), src);
+            not.encoding(enc);
+            assertArrayEquals("Logical not dst=" + dst + ", src=" + src,
+                java.util.HexFormat.of().parseHex(expected[i]), enc._bits.toByteArray());
+        }
+    }
+
+    @Test
+    public void testLogicalNotExecution() throws java.io.IOException {
+        var dir = java.nio.file.Path.of("build/objs");
+        java.nio.file.Files.createDirectories(dir);
+        java.nio.file.Files.writeString(dir.resolve("x86LogicalNot.smp"),
+            "val logicalNot = { int x -> return !x; };");
+        java.nio.file.Files.writeString(dir.resolve("x86LogicalNot.c"), """
+            #include <limits.h>
+            extern long long logicalNot(long long);
+            int main(void) {
+                long long inputs[] = {0, 1, -1, LLONG_MIN, LLONG_MAX, 1LL << 32};
+                for (unsigned i = 0; i < sizeof(inputs)/sizeof(inputs[0]); i++)
+                    if (logicalNot(inputs[i]) != (inputs[i] == 0)) return 1;
+                return 0;
+            }
+            """);
+        com.seaofnodes.simple.TestC.run("build/objs", "x86LogicalNot", "", -1);
+    }
+
+    @Test
+    public void testMultiplyImmediateRegisters() {
+        // Destination, source, expected REX and ModRM. Cross the register-8
+        // boundary in both directions, with low/low and high/high controls.
+        int[][] cases = {{1, 9, 0x49, 0xC9}, {9, 1, 0x4C, 0xC9},
+                         {1, 2, 0x48, 0xCA}, {9, 10, 0x4D, 0xCA}};
+        for (int immediate : new int[]{11, -11, 123456789, -123456789}) {
+            CodeGen code = new CodeGen("return arg * " + immediate + ";")
+                .driver(CodeGen.Phase.Select, "x86_64_v2", "SystemV");
+            var mul = code._stop.walk(n -> n instanceof MulIX86 ? n : null);
+            assertNotNull("Must exercise immediate multiply", mul);
+            for (int[] regs : cases) {
+                var enc = new FixedRegisterEncoding(
+                    code, mul, regs[0], mul.in(1), regs[1]);
+                ((MulIX86)mul).encoding(enc);
+                boolean small = immediate == 11 || immediate == -11;
+                assertEquals("REX for dst=" + regs[0] + ", src=" + regs[1], regs[2], enc.read1(0));
+                assertEquals(small ? 0x6B : 0x69, enc.read1(1));
+                assertEquals(regs[3], enc.read1(2));
+                assertEquals(small ? 4 : 7, enc._bits.size());
+                assertEquals(immediate, small ? (byte)enc.read1(3) : enc.read4(3));
+            }
+        }
+    }
+    @Test
+    public void testMemoryCompare64Immediate32() {
+        for (int immediate : new int[]{123456789, -123456789}) {
+            String src = "int[] !a = new int[2]; a[0] = arg; return a[arg & 1] == " + immediate + ";";
+            CodeGen code = new CodeGen(src).driver(CodeGen.Phase.Encoding, "x86_64_v2", "SystemV");
+            var cmp = code._stop.walk(n -> n instanceof CmpMemX86 ? n : null);
+            assertNotNull("Must exercise a memory comparison", cmp);
+            var enc = code._encoding;
+            int start = enc._opStart[cmp._nid];
+
+            // REX.W, 81 /7, SIB with scale 8, disp8, and a sign-extended imm32.
+            assertEquals(0x48, enc.read1(start) & 0xF8);
+            assertEquals(0x81, enc.read1(start + 1));
+            assertEquals(0x7C, enc.read1(start + 2));
+            assertEquals(0xC0, enc.read1(start + 3) & 0xC0);
+            assertEquals(8, enc.read1(start + 4));
+            assertEquals(immediate, enc.read4(start + 5));
+            assertEquals("CMP r/m64 uses four immediate bytes", 9, enc._opLen[cmp._nid]);
+
+            // SETE must immediately follow the CPU's nine-byte CMP instruction.
+            assertEquals(0x0F, enc.read1(start + 9));
+            assertEquals(0x94, enc.read1(start + 10));
+        }
+    }
+
+    /** Exercise instruction encoders with explicit registers, independent of allocator choices. */
+    private static class FixedRegisterEncoding extends Encoding {
+        private final Node _dst, _src;
+        private final short _dstReg, _srcReg;
+
+        FixedRegisterEncoding(CodeGen code, Node dst, int dstReg, Node src, int srcReg) {
+            super(code);
+            _dst = dst;
+            _src = src;
+            _dstReg = (short)dstReg;
+            _srcReg = (short)srcReg;
+        }
+
+        @Override public short reg(Node n) {
+            if (n == _dst) return _dstReg;
+            if (n == _src) return _srcReg;
+            throw new AssertionError("Unexpected register lookup");
+        }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
new file mode 100644
index 00000000..20aac367
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
@@ -0,0 +1,380 @@
+package com.seaofnodes.simple.evaluator;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.Utils;
+import java.util.*;
+
+public class Evaluator {
+
+    private static final Object MEMORY = new Object();
+
+    public record Obj(TypeStruct struct, Object[] fields) {
+        private void init(IdentityHashMap<Obj, Integer> objs) {
+            var oid = objs.get(this);
+            if (oid != null) {
+                if (oid != 0) objs.put(this, 0);
+                return;
+            }
+            objs.put(this, -1);
+            for (var obj : fields) {
+                if (obj instanceof Obj o) o.init(objs);
+            }
+        }
+        private static int p(StringBuilder sb, IdentityHashMap<Obj, Integer> objs, int id, String indentation, String step, String sep, Object obj) {
+            if (obj instanceof Obj o) return o.p(sb, objs, id, indentation, step, sep);
+            sb.append(obj);
+            return id;
+        }
+        private int p(StringBuilder sb, IdentityHashMap<Obj, Integer> objs, int id, String indentation, String step, String sep) {
+            var cid = objs.get(this);
+            assert cid != null;
+            if (cid > 0) {
+                sb.append("obj@").append(cid);
+                return id;
+            }
+            if (struct._name.equals("[u8]")) {
+                sb.append('"');
+                for (int i=struct._fields.length-1; i<fields.length; i++) {
+                    var v = fields[i];
+                    if (v == null) v = 0;
+                    assert v instanceof Number;
+                    var n = ((Number)v).byteValue() & 0xFF;
+                    if (n >= 0x20 && n < 0x80) {
+                        if (n == 0x22 || n == 0x5C) sb.append("\\");
+                        sb.append((char)n);
+                    } else {
+                        sb.append("\\x").append("0123456789abcdef".charAt(n >> 4)).append("0123456789abcdef".charAt(n & 0xF));
+                    }
+                }
+                sb.append('"');
+                return id;
+            }
+            sb.append("Obj<").append(struct._name).append(">");
+            if (cid == 0) {
+                cid = id++;
+                objs.put(this, cid);
+                sb.append("@").append(cid);
+            }
+            sb.append("{");
+            if (struct._fields.length == 0) {
+                assert !struct.isAry();
+                sb.append("}");
+                return id;
+            }
+            String nextIndent = indentation + step;
+            int e = struct._fields.length - 1;
+            for(int i=0; i<e; i++) {
+                sb.append(nextIndent).append(struct._fields[i]._fname).append("=");
+                id = p(sb, objs, id, nextIndent, step, sep, fields[i]);
+                sb.append(sep);
+            }
+            sb.append(nextIndent).append(struct._fields[e]._fname).append("=");
+            if (struct.isAry()) {
+                sb.append("[");
+                if (fields.length > e) {
+                    String innerIndent = nextIndent + step;
+                    sb.append(innerIndent);
+                    id = p(sb, objs, id, nextIndent, step, sep, fields[e]);
+                    for (int i = e+1; i < fields.length; i++) {
+                        sb.append(sep).append(innerIndent);
+                        id = p(sb, objs, id, nextIndent, step, sep, fields[i]);
+                    }
+                    sb.append(nextIndent);
+                }
+                sb.append("]");
+            } else {
+                id = p(sb, objs, id, nextIndent, step, sep, fields[e]);
+            }
+            sb.append(indentation).append("}");
+            return id;
+        }
+        private StringBuilder p(StringBuilder sb, String indentation, String step, String sep) {
+            var objs = new IdentityHashMap<Obj, Integer>();
+            init(objs);
+            p(sb, objs, 1, indentation, step, sep);
+            return sb;
+        }
+        @Override
+        public String toString() {
+            if (struct._name.equals("[u8]")) {
+                var sb = new StringBuilder();
+                for (int i=struct._fields.length-1; i<fields.length; i++) {
+                    var v = fields[i];
+                    if (v == null) v = 0;
+                    assert v instanceof Number;
+                    var n = ((Number)v).byteValue() & 0xFF;
+                    sb.append((char)n);
+                }
+                return sb.toString();
+            }
+            return p(new StringBuilder(), "", "", ",").toString();
+        }
+        public String pretty() {
+            return p(new StringBuilder(), "\n", "  ", "").toString();
+        }
+    }
+
+    private static int getFieldIndex(TypeStruct struct, MemOpNode memop, long off) {
+        int idx = struct.find(memop._name);
+        if( idx >= 0 ) return idx;
+        throw new AssertionError("Field "+memop._name+" not found in struct " + struct._name);
+    }
+
+    public enum Status {
+        TIMEOUT,
+        FALLTHROUGH
+    }
+
+    /**
+     * Find the start node from some node in the graph or null if there is no start node
+     */
+    private static StartNode findStart(BitSet visit, Node node) {
+        if (node == null) return null;
+        if( visit.get(node._nid) ) return null;
+        visit.set(node._nid);
+        StartNode start = node instanceof StartNode ? (StartNode) node : null;
+        for( Node def : node._inputs ) {
+            var res = findStart(visit,def);
+            if( res != null ) start = res;
+        }
+        for( Node use : node._outputs ) {
+            var res = findStart(visit,use);
+            if( res != null ) start = res;
+        }
+        return start;
+    }
+
+    private final Object[] values;
+    private final ArrayList<Object> phiCache = new ArrayList<>();
+    private final StartNode start;
+    private final Scheduler.Block startBlock;
+
+    public Evaluator(Node graph) {
+        var visited = new BitSet();
+        this.start = findStart(visited, graph);
+        if (this.start == null) {
+            this.values = null;
+            this.startBlock = null;
+            return;
+        }
+        this.startBlock = Scheduler.schedule(this.start);
+        this.values = new Object[visited.length()];
+    }
+
+    private long div(DivNode div) {
+        long in2 = vall(div.in(2));
+        return in2 == 0 ? 0 : vall(div.in(1)) / in2;
+    }
+    private double div(DivFNode div) {
+        double in2 = vald(div.in(2));
+        return in2 == 0 ? 0 : vald(div.in(1)) / in2;
+    }
+
+    private static long offToIdx(long off, TypeStruct t) {
+        off -= t.aryBase();
+        int scale = t.aryScale();
+        long mask = (1L << scale)-1;
+        assert (off & mask) == 0;
+        return off>>scale;
+    }
+
+    private Object alloc(NewNode alloc) {
+        TypeStruct type = alloc._ptr._obj;
+        Object[] body=null;
+        int num;
+        if( type.isAry() ) {
+            long sz = (Long)val(alloc.size());
+            long n = offToIdx(sz, type);
+            if( n < 0 )
+                throw new NegativeArraySizeException(""+n);
+            body = new Object[(int)n+1]; // Array body
+            var elem = type._fields[1]._t;
+            if (elem instanceof TypeInteger) {
+                for (int i=0; i<n; i++) body[i+1] = 0L;
+            } else if (elem instanceof TypeFloat) {
+                for (int i = 0; i < n; i++) body[i+1] = 0D;
+            } else {
+                assert elem instanceof TypeMemPtr;
+            }
+            // Length value
+            body[0] = n;
+        } else {
+            body = new Object[num = type._fields.length];
+            for( int i=0; i<num; i++ )
+                body[i] = switch( alloc._ptr._obj._fields[i]._t ) {
+                case TypeInteger ti -> 0L;
+                case TypeFloat tf -> 0D;
+                default -> null;
+                };
+        }
+        return new Object[]{new Obj(type,body),null};
+    }
+
+    private Object load(LoadNode load) {
+        var from = (Obj)val(load.ptr());
+        var off = vall(load.off());
+        var idx = getFieldIndex(from.struct, load, (Long)off);
+        if( idx==from.struct._fields.length-1 && from.struct.isAry() ) {
+            long len = from.fields.length - from.struct._fields.length + 1;
+            long i = offToIdx(off, from.struct);
+            if( i < 0 || i >= len )
+                throw new ArrayIndexOutOfBoundsException("Array index out of bounds " + i + " < " + len);
+            return from.fields[(int)i+from.struct._fields.length-1];
+
+        } else
+            return from.fields[idx];
+    }
+
+    private Object store(StoreNode store) {
+        var to = (Obj)val(store.ptr());
+        var off = vall(store.off());
+        var val = val(store.val());
+        var idx = getFieldIndex(to.struct, store, (Long)off);
+        if( idx==to.struct._fields.length-1 && to.struct.isAry() ) {
+            long len = to.fields.length - to.struct._fields.length + 1;
+            long i = offToIdx(off, to.struct);
+            if( i < 0 || i >= len )
+                throw new RuntimeException("Array index out of bounds " + off + " <= " + len);
+            to.fields[(int)i+to.struct._fields.length-1] = val;
+        } else
+            to.fields[idx] = val;
+        return null;
+    }
+
+    private static boolean isTrue(Object obj) {
+        if (obj == null) return false;
+        if (obj instanceof Number n) return n.longValue() != 0;
+        return true;
+    }
+
+    private Object val(Node node) {
+        return values[node._nid];
+    }
+
+    private long vall(Node node) {
+        var v = val(node);
+        if (v instanceof Number n) return n.longValue();
+        throw new AssertionError("Not a long " + v);
+    }
+    private double vald(Node node) {
+        var v = val(node);
+        if (v instanceof Number n) return n.doubleValue();
+        if( v == null ) return 0;
+        throw new AssertionError("Not a double " + v);
+    }
+
+    private Object cons(ConstantNode cons) {
+        var type = cons.compute();
+        if (type instanceof TypeInteger i) return i.isConstant() ? i.value() : Integer.MAX_VALUE;
+        if (type instanceof TypeFloat i) return i.value();
+        return null;
+    }
+
+    private Object exec(Node node) {
+        return switch (node) {
+            case ConstantNode cons  -> cons(cons);
+            case AddNode      add   -> vall(add.in(1)) + vall(add.in(2));
+            case AddFNode     add   -> vald(add.in(1)) + vald(add.in(2));
+            case BoolNode.EQF eq    -> vald(eq.in(1)) == vald(eq.in(2)) ? 1L : 0L;
+            case BoolNode.LEF le    -> vald(le.in(1)) <= vald(le.in(2)) ? 1L : 0L;
+            case BoolNode.LTF lt    -> vald(lt.in(1)) <  vald(lt.in(2)) ? 1L : 0L;
+            case BoolNode.EQ  eq    -> Objects.equals(val(eq.in(1)), val(eq.in(2))) ? 1L : 0L;
+            case BoolNode.LE  le    -> vall(le.in(1)) <= vall(le.in(2)) ? 1L : 0L;
+            case BoolNode.LT  lt    -> vall(lt.in(1)) <  vall(lt.in(2)) ? 1L : 0L;
+            case DivNode      div   -> div(div);
+            case DivFNode     div   -> div(div);
+            case MinusNode    minus -> -vall(minus.in(1));
+            case MinusFNode   minus -> -vald(minus.in(1));
+            case MulNode      mul   -> vall(mul.in(1)) * vall(mul.in(2));
+            case MulFNode     mul   -> vald(mul.in(1)) * vald(mul.in(2));
+            case NotNode      not   -> isTrue(val(not.in(1))) ? 0L : 1L;
+            case SubNode      sub   -> vall(sub.in(1)) - vall(sub.in(2));
+            case SubFNode     sub   -> vald(sub.in(1)) - vald(sub.in(2));
+            case ShlNode      shl   -> vall(shl.in(1)) << vall(shl.in(2));
+            case ShrNode      shr   -> vall(shr.in(1)) >>> vall(shr.in(2));
+            case SarNode      sar   -> vall(sar.in(1)) >> vall(sar.in(2));
+            case AndNode      and   -> vall(and.in(1)) & vall(and.in(2));
+            case  OrNode      or    -> vall(or .in(1)) | vall(or .in(2));
+            case XorNode      xor   -> vall(xor.in(1)) ^ vall(xor.in(2));
+            case CastNode     cast  -> val(cast.in(1));
+            case RoundF32Node rnd   -> (double)(float)vald(rnd.in(1));
+            case ToIntegerNode cvt -> (long)vald(cvt.in(1));
+            case ToFloatNode  cast  -> (double)vall(cast.in(1));
+            case LoadNode     load  -> load(load);
+            case StoreNode    store -> store(store);
+            case NewNode      alloc -> alloc(alloc);
+            case CProjNode    cproj -> ((Object[])val(cproj.ctrl()))[cproj._idx];
+            case ProjNode     proj  -> ((Object[])val( proj.in(0) ))[ proj._idx];
+            case MemMergeNode mem   -> null;
+            case ReadOnlyNode ro    -> val(ro.in(1));
+            case CallNode     call  -> Utils.TODO(); // should not reach here, go the IfNode route
+            default                 -> throw new AssertionError("Unexpected node " + node);
+        };
+    }
+
+    /**
+     * Run the graph until either a return is found or the number of loop iterations are done.
+     */
+    public Object evaluate(long parameter, int loops) {
+        if (start == null) return Status.TIMEOUT;
+        var s = new Object[start.compute()._types.length];
+        s[1] = MEMORY;
+        s[2] = parameter;
+        values[start._nid] = s;
+        int i=0;
+        Scheduler.Block block = this.startBlock;
+        for(;;) {
+            for(; i<block.nodes().length;i++) values[block.nodes()[i]._nid] = exec(block.nodes()[i]);
+            i=0;
+            switch (block.exit()) {
+            case null:
+                return Status.FALLTHROUGH;
+            case ReturnNode ret :  return val(ret .expr());
+            case IfNode ifn:
+                block = block.next()[isTrue(val(ifn.in(1))) ? 0 : 1];
+                if (block == null) return Status.FALLTHROUGH;
+                break;
+            case RegionNode region:
+                if (loops-- <= 0) return Status.TIMEOUT;
+                int exit = block.exitId();
+                assert exit > 0 && region.nIns() > exit;
+                block = block.next()[0];
+                assert block != null;
+                for (; i < block.nodes().length; i++) {
+                    if (!(block.nodes()[i] instanceof PhiNode phi)) break;
+                    var val = region instanceof FunNode fun && "main".equals(fun._name) && ((ParmNode)phi)._idx==2 && exit==1
+                            ? parameter
+                            : val(phi.in(exit));
+                    phiCache.add(val);
+                }
+                for (i=0; i<phiCache.size(); i++) {
+                    values[block.nodes()[i]._nid] = phiCache.get(i);
+                }
+                phiCache.clear();
+                break;
+            default:
+                throw Utils.TODO("Unexpected control node " + block.exit());
+            }
+        }
+    }
+
+    public static Object evaluate(StopNode graph) {
+        return evaluate(graph, 0);
+    }
+
+    public static Object evaluate(StopNode graph, long parameter) {
+        return evaluate(graph, parameter, 1000);
+    }
+
+    public static Object evaluate(StopNode graph, long parameter, int loops) {
+        var res = evaluateWithResult(graph, parameter, loops);
+        if (res == Status.TIMEOUT) throw new RuntimeException("Timeout");
+        return res;
+    }
+
+    public static Object evaluateWithResult(StopNode graph, long parameter, int loops) {
+        return new Evaluator(graph).evaluate(parameter, loops);
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java
new file mode 100644
index 00000000..c837bd6f
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java
@@ -0,0 +1,605 @@
+package com.seaofnodes.simple.evaluator;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.util.Utils;
+import java.util.*;
+
+/**
+ * A late scheduler for test cases.
+ * <br>
+ * <br>
+ * This scheduler is used for tests and is not the final scheduler.
+ * <br>
+ * <br>
+ * The scheduler schedules not as late as possible. Since it is just for test cases this is fine.
+ * A better scheduler will try to place nodes outside of loops. Due to the schedule late strategy
+ * this scheduler might place initialization code in loops.
+ * <br>
+ * We schedule late here since memory edges have some implicit information. There can only be one
+ * memory edge (for a field) at a time. However, before <code>if</code> statements this might split.
+ * When scheduling early a store might be moved out of the loop but then there are two edges alive.
+ * The one through the store node and the adjacent one. This is an invalid schedule and instead of
+ * handling this case a late scheduler does not have this problem as memory edges are combined
+ * through phi nodes.
+ * <br>
+ * <br>
+ * A bit about this scheduler. It first discovers all alive nodes and allocates side data for them.
+ * Then the control flow graph is build. Then, all phis are placed and finally all the remaining nodes
+ * in an order where a node is placed when all alive uses are placed. Finally, the output is produced.
+ */
+public class Scheduler {
+
+    /**
+     * A basic block with a schedule of the containing nodes.
+     *
+     * @param nodes The nodes in the final schedule of this block
+     * @param exit The exit node of this block.
+     * @param exitId In case the next block is a region this gives the entry id into the region.
+     * @param next The next blocks.
+     */
+    public record Block(Node[] nodes, Node exit, int exitId, Block[] next) {}
+
+    /**
+     * Definition of a block in the building process.
+     */
+    private static class BasicBlock {
+
+        /**
+         * Dominator of this block
+         */
+        final BasicBlock dom;
+        /**
+         * Id of this block where <code>a.depth < b.depth</code> means that a is before b or
+         * both are in different branches.
+         */
+        final int depth;
+        /**
+         * Previous blocks
+         */
+        final BasicBlock[] prev;
+        /**
+         * Entry to this block
+         */
+        final Node entry;
+        /**
+         * Schedules node in reverse order.
+         */
+        final ArrayList<Node> reverseSchedule = new ArrayList<>();
+
+        /**
+         * Initialize the block.
+         * @param entry The node that started this block
+         * @param depth The depth of this node. All previous nodes need to have a lower value.
+         * @param prev The previous blocks.
+         */
+        BasicBlock(Node entry, int depth, BasicBlock... prev) {
+            BasicBlock dom = null;
+            int max = -1;
+            for(var bb: prev) {
+                max = Math.max(max, bb.depth);
+                dom = dom==null?bb:dom(dom, bb);
+            }
+            assert depth > max;
+            this.dom = dom;
+            this.depth = depth;
+            this.entry = entry;
+            this.prev = prev;
+        }
+        BasicBlock(Node entry, BasicBlock prev) {
+            this(entry,prev.depth+1,prev);
+        }
+
+    }
+
+    /**
+     * Ancillary data for nodes used during the scheduling process.
+     */
+    private static class NodeData {
+
+        /**
+         * The node this ancillary data is used for.
+         */
+        final Node node;
+
+        /**
+         * Number of alive users not yet scheduled.
+         */
+        int users = 1;
+
+        /**
+         * Block into which the node should be placed so far.
+         * This will be updated with every placed use.
+         */
+        BasicBlock block;
+
+        /**
+         * Initialize ancillary data for a node
+         * @param node The node this ancillary data is associated with.
+         */
+        NodeData(Node node) {
+            this.node = node;
+        }
+
+    }
+
+    /**
+     * Ancillary data for nodes.
+     */
+    private final IdentityHashMap<Node, NodeData> data = new IdentityHashMap<>();
+    /**
+     * List of nodes which can be placed since all users are placed.
+     */
+    private final Stack<NodeData> scheduleQueue = new Stack<>();
+
+    /**
+     * Get the ancillary data for an alive node.
+     * @param node The node for which the ancillary data is requested.
+     * @return The ancillary data for the node.
+     */
+    NodeData d(Node node) {
+        return od(node).orElseThrow(AssertionError::new);
+    }
+
+    /**
+     * Get the ancillary data for a potentially dead node.
+     * @param node The node for which the ancillary data is requested.
+     * @return The ancillary data for the node an alive node or
+     * <code>Optional.empty()</code> for <code>null</code> or dead nodes.
+     */
+    Optional<NodeData> od(Node node) {
+        return Optional.ofNullable(data.get(node));
+    }
+
+    /**
+     * Checks a node for validity
+     * @param data The node to check.
+     * @return true if all placed inputs are before this node.
+     */
+    private boolean isValid(NodeData data) {
+        return data.node._inputs.stream()
+                .map(i->i==null?null:d(i))
+                .map(d->d==null||d.users>0?null:d.block)
+                .allMatch(d->d==null||dom(d, data.block)==d);
+    }
+
+    /**
+     * Checks that node is not XCtrl.
+     * @param node The node to check.
+     * @return true if the node is not XCtrl.
+     */
+    private static boolean isNotXCtrl(Node node) {
+        return !(node instanceof ConstantNode c && c.compute() == Type.XCONTROL) && !(node instanceof XCtrlNode);
+    }
+
+    /**
+     * Return the dominator of <code>a</code> and <code>b</code>
+     * @param a Block a
+     * @param b Block b
+     * @return The dominator of <code>a</code> and <code>b</code>
+     */
+    private static BasicBlock dom(BasicBlock a, BasicBlock b) {
+        while (a!=b) {
+            if (a.depth >= b.depth) a=a.dom;
+            if (b.depth > a.depth) b=b.dom;
+        }
+        return a;
+    }
+
+    /**
+     * Return if a is before b.
+     * @param a Block a
+     * @param b Block b
+     * @return true is a is before b.
+     */
+    private static boolean isBefore(BasicBlock a, BasicBlock b) {
+        while (b.depth > a.depth) {
+            while (b.dom.depth > a.depth) b = b.dom;
+            for (int i=0; i<b.prev.length-1; i++) {
+                if (isBefore(a, b.prev[i])) return true;
+            }
+            b = b.prev[b.prev.length-1];
+        }
+        return a == b;
+    }
+
+    /**
+     * Is node placed during the control flow graph build.
+     * @param data Node to check.
+     * @return true if node is placed during the control flow graph build.
+     */
+    private static boolean isPinnedNode(NodeData data) {
+        return data.node instanceof CFGNode || data.node instanceof PhiNode;
+    }
+
+    /**
+     * Refine placement of a node.
+     * @param data The node to refine.
+     * @param block The block before the node should be scheduled.
+     */
+    private void refinePlacement(NodeData data, BasicBlock block) {
+        assert !isPinnedNode(data);
+        data.block = data.block == null ? block : dom(data.block, block);
+        assert isValid(data);
+    }
+
+    /**
+     * Refine placement if before is happening before data
+     * @param data The node for which the placement should be refined.
+     * @param before The node before which the data node should be placed.
+     */
+    private void optionalRefinePlacement(NodeData data, Node before) {
+        od(before).ifPresent(d->{
+            // before might be in a different branch. So check this case with isBefore
+            // and only refine the placement if it is not in a different branch.
+            if (isBefore(d.block, data.block)) refinePlacement(data, d.block);
+        });
+    }
+
+    /**
+     * Schedule all nodes not yet scheduled.
+     */
+    private void doSchedule() {
+        while (!scheduleQueue.isEmpty()) {
+            var data = scheduleQueue.pop();
+            assert !isPinnedNode(data);
+
+            assert data.block != null;
+            assert data.users == 0;
+
+            if (data.node instanceof MemOpNode l && l._isLoad) {
+                assert isValid(data);
+                // Handle anti-deps of load nodes.
+                // At this point all anti-dep nodes are scheduled,
+                // but they did not refine the placement
+                // so do that now.
+                var mem = data.node.in(1);
+                for(var out : mem._outputs) {
+                    if (out instanceof PhiNode p) {
+                        var r = p.in(0);
+                        for (int i = 1; i < p.nIns(); i++) {
+                            if (p.in(i) == mem) optionalRefinePlacement(data, r.in(i));
+                        }
+                    } else if (!(out instanceof MemOpNode ld && ld._isLoad)) {
+                        optionalRefinePlacement(data, out);
+                    }
+                }
+            }
+
+            assert isValid(data);
+            data.block.reverseSchedule.add(data.node);
+
+            for(var in:data.node._inputs) {
+                if (in!=null) update(d(in), data.block);
+            }
+            if (data.node instanceof MemOpNode s && !s._isLoad) {
+                // Store nodes have anti-deps to load nodes.
+                // So decrease the uses of these loads when the store is placed.
+                for (var out: ((Node)s).in(1)._outputs) {
+                    if (out instanceof MemOpNode ld && ld._isLoad) od(out).ifPresent(this::decUsers);
+                }
+            }
+        }
+
+        // Now all nodes should be placed and have a block assigned
+        assert this.data.values().stream().noneMatch(d->d.block==null);
+    }
+
+    /**
+     * Decrement the not-yet-placed users of a block.
+     * @param data The node for which the users should be decremented.
+     */
+    private void decUsers(NodeData data) {
+        assert data.users > 0;
+        if (--data.users == 0) {
+            assert data.block != null;
+            assert isValid(data);
+
+            // When all users are gone this node can be scheduled.
+            scheduleQueue.push(data);
+        }
+    }
+
+    /**
+     * Update the placement of a node
+     * @param data The node to update
+     * @param block The block before which the node should happen.
+     */
+    private void update(NodeData data, BasicBlock block) {
+        assert block != null;
+        if (data.users == 0) {
+            assert isPinnedNode(data);
+            return;
+        }
+        refinePlacement(data, block);
+        decUsers(data);
+    }
+
+    /**
+     * Checks if a CFG node is ready to be placed. This is used for regions joining branches.
+     * @param node The CFG node to check
+     * @return true if all parents of a CFG node are placed.
+     */
+    private boolean isCFGNodeReady(Node node) {
+        if (node instanceof LoopNode l) {
+            assert d(l.in(1)).block != null;
+        } else if (node instanceof RegionNode r) {
+            for(int i=1; i<r.nIns(); i++) {
+                if (od(r.in(i)).map(d->d.block==null).orElse(false)) return false;
+            }
+        } else if (node instanceof XCtrlNode) {
+            return false;
+        } else {
+            assert d(node.in(0)).block != null;
+        }
+        return true;
+    }
+
+    /**
+     * Schedule all phi nodes.
+     * @param phiQueue List of all the phi nodes to schedule.
+     */
+    private void schedulePhis(Stack<NodeData> phiQueue) {
+        while(!phiQueue.empty()) {
+            var data = phiQueue.pop();
+            var phi = (PhiNode) data.node;
+            var r = phi.in(0);
+            data.block = d(r).block;
+            for(int i=1; i<phi.nIns(); i++) {
+                var in = phi.in(i);
+                od(r.in(i)).ifPresent(d->update(d(in), d.block));
+            }
+        }
+    }
+
+    /**
+     * Build the control flow graph.
+     * @param start The start node.
+     */
+    private void doBuildCTF(StartNode start) {
+        var queue = new Stack<NodeData>();
+        var phiQueue = new Stack<NodeData>();
+        queue.push(d(start));
+        while (!queue.isEmpty()) {
+            var data = queue.pop();
+            var node = data.node;
+            assert node instanceof CFGNode;
+            BasicBlock block = switch (node) {
+            case StartNode s -> new BasicBlock(s, 0);
+            case LoopNode l -> new BasicBlock(l, d(l.in(1)).block);
+            case RegionNode r -> {
+                    var prev = new ArrayList<BasicBlock>();
+                    int depth = 0;
+                    for(int i=1; i<r.nIns(); i++) {
+                        if( !od(r.in(i)).isPresent() ) continue;
+                        BasicBlock bb = d(r.in(i)).block;
+                        prev.add(bb);
+                        depth = Math.max(depth,bb.depth);
+                    }
+                    yield new BasicBlock(r, depth+1, prev.toArray(BasicBlock[]::new));
+            }
+            case IfNode i -> d(i.in(0)).block;
+            case ReturnNode ret -> d(ret .in(0)).block;
+            case CallNode call -> throw Utils.TODO();
+            default -> new BasicBlock(node, d(node.in(0)).block);
+            };
+            data.block = block;
+            if (node instanceof RegionNode r) {
+                // Regions might have phis which need to be scheduled.
+                // Put them on a list for later scheduling.
+                for (var out:r._outputs) {
+                    if (out instanceof PhiNode p) {
+                        var d = this.data.get(p);
+                        if (d!=null) {
+                            d.users=0;
+                            phiQueue.push(d);
+                        }
+                    }
+                }
+            }
+            if( node instanceof FunNode fun ) {
+                // Cannot find CFG user from fun via a naive search, because always find
+                // Return but Return is not always the one CFG user.
+                CFGNode n = fun.uctrl();
+                assert isCFGNodeReady(n) && d(n).block==null;
+                queue.push(d(n));
+            } else if( !(node instanceof ReturnNode) ) {
+                for (Node n : node._outputs)
+                    if(n instanceof CFGNode && isCFGNodeReady(n) && d(n).block == null)
+                        queue.push(d(n));
+            }
+            var b = block;
+            for(var in:data.node._inputs) od(in).ifPresent(d->update(d, b));
+        }
+
+        // Schedule all phi nodes.
+        schedulePhis(phiQueue);
+    }
+
+    /**
+     * Mark a node alive and create ancillary data for it.
+     * @param queue List into which this node should be placed if it needs to be visited.
+     * @param node Node which should be marked alive.
+     * @param cfg If this node is a CFG node.
+     */
+    private void markAlive(Stack<NodeData> queue, Node node, boolean cfg) {
+        var nd = od(node).orElse(null);
+        if (nd != null) {
+            // Node was already visited, just increase the users.
+            if (nd.users>0) nd.users++;
+            return;
+        }
+        assert node instanceof CFGNode == cfg;
+        assert isNotXCtrl(node);
+        nd = new NodeData(node);
+        if (cfg) nd.users=0;
+        data.put(node, nd);
+        queue.push(nd);
+    }
+
+    /**
+     * Mark all alive nodes.
+     * First all CFG nodes are marked, then all other nodes.
+     * @param node THe start node.
+     */
+    private void doMarkAlive(Node node) {
+        var cfgQueue = new Stack<NodeData>();
+        var dataQueue = new Stack<NodeData>();
+        var mem = new Stack<NodeData>();
+        markAlive(cfgQueue, node, true);
+        // Mark all CFG nodes.
+        while (!cfgQueue.isEmpty()) {
+            var data = cfgQueue.pop();
+            node = data.node;
+            assert node instanceof CFGNode;
+            if (!(node instanceof ReturnNode) ) {
+                for (var out : node._outputs) if (out!=null && out instanceof CFGNode && isNotXCtrl(out)) markAlive(cfgQueue, out, true);
+            }
+            for (var in : node._inputs) if(in!=null && !(in instanceof CFGNode) && isNotXCtrl(in)) markAlive(dataQueue, in, false);
+        }
+        // Mark all other nodes.
+        while (!dataQueue.isEmpty()) {
+            var data = dataQueue.pop();
+            node = data.node;
+            assert !(node instanceof CFGNode);
+            if (node instanceof PhiNode phi) {
+                var r = phi.in(0);
+                for (int i=1; i<phi.nIns(); i++) {
+                    if (od(r.in(i)).isPresent()) markAlive(dataQueue, phi.in(i), false);
+                }
+            } else {
+                for (var in : node._inputs) if (in != null && !(in instanceof CFGNode)) markAlive(dataQueue, in, false);
+            }
+            if (node instanceof MemOpNode s && !s._isLoad) mem.push(data);
+        }
+        // Handle store nodes and increase load with an anti-dep to the store.
+        while (!mem.isEmpty()) {
+            var data = mem.pop();
+            node = data.node;
+            for(var out:node.in(1)._outputs) {
+                if (out instanceof MemOpNode ld && ld._isLoad) od(out).ifPresent(d->d.users++);
+            }
+        }
+    }
+
+    /**
+     * Helper function to append the nodes of a block to an array of nodes
+     * @param arr The array the nodes of a block should be appended to.
+     * @param node A potentially separator node
+     * @param block The block from which the nodes should be appended.
+     * @return The combined new array.
+     */
+    private static Node[] appendNodes(Node[] arr, Node node, BasicBlock block) {
+        var idx = arr.length;
+        arr = Arrays.copyOf(arr, arr.length+block.reverseSchedule.size()+(node==null?0:1));
+        if (node != null) arr[idx++] = node;
+        for(int i=block.reverseSchedule.size()-1;i>=0;i--) {
+            arr[idx++] = block.reverseSchedule.get(i);
+        }
+        return arr;
+    }
+
+    /**
+     * Find the CFG output of a node
+     * @param node The node
+     * @return The CFG output of the node.
+     */
+    private static CFGNode findSingleCFGOut(Node node) {
+        if (node instanceof StartNode) {
+            for(var n:node._outputs)
+                if (n instanceof FunNode fun && "main".equals(fun._name) )
+                   return fun;
+            return null;
+        }
+        if( node instanceof FunNode fun ) return fun.uctrl();
+        assert node._outputs.stream().filter(x -> x instanceof CFGNode).limit(2).count()<=1;
+        for(var n:node._outputs) if(n instanceof CFGNode cfg) return cfg;
+        return null;
+    }
+
+    /**
+     * Build the final data structure after all the scheduling happened.
+     * @param start The start node
+     * @return The final schedule.
+     */
+    private Block build(Node start) {
+        var blocks = new IdentityHashMap<Node, Block>();
+        var queue = new Stack<NodeData>();
+        queue.push(d(start));
+
+        // Visit all CFG nodes and create blocks for them.
+        // This can combine blocks.
+        while(!queue.isEmpty()) {
+            var data = queue.pop();
+            var first = data.node;
+            Node prev;
+            var last = first;
+            Node[] arr = new Node[0];
+            if (first instanceof RegionNode) {
+                var nodes = new ArrayList<Node>();
+                for(var out: first._outputs) {
+                    if (out instanceof PhiNode) {
+                        if(od(out).isPresent()) nodes.add(out);
+                    }
+                }
+                arr = nodes.toArray(arr);
+            }
+            arr = appendNodes(arr, null, data.block);
+            assert !(first instanceof IfNode);
+            for(;;) {
+                prev = last;
+                last = findSingleCFGOut(last);
+                if (last == null) break;
+                if (last instanceof RegionNode) {
+                    if (blocks.get(last) == null && last != first)
+                        queue.push(d(last));
+                    break;
+                }
+                if (last instanceof ReturnNode) break;
+                if (last instanceof IfNode if_) {
+                    for(var out:if_._outputs) if (out instanceof CFGNode && blocks.get(out) == null) queue.push(d(out));
+                    break;
+                }
+                data = d(last);
+                arr = appendNodes(arr, data.node, data.block);
+            }
+            blocks.put(first, switch(last) {
+                case null -> new Block(arr, null, -1, new Block[0]);
+                case IfNode i -> new Block(arr, i, -1, new Block[2]);
+                case RegionNode r -> new Block(arr, r, r._inputs.find(prev), new Block[1]);
+                case ReturnNode r -> new Block(arr, r   , -1, new Block[0]);
+                default -> throw new AssertionError("Unexpected block exit node");
+            });
+        }
+        // Update the next pointer of all blocks.
+        for (var block: blocks.values()) {
+            switch(block.exit) {
+                case null: break;
+                case IfNode i:
+                    for(var out:i._outputs) if (out instanceof CProjNode p) block.next[p._idx] = blocks.get(p);
+                    break;
+                case RegionNode r:
+                    block.next[0] = blocks.get(r);
+                    break;
+                default:
+                    assert block.exit instanceof ReturnNode;
+            }
+        }
+        // And return the block for the start node.
+        return blocks.get(start);
+    }
+
+    /**
+     * Create a schedule for the program reachable from start.
+     * @param start The start node
+     * @return The final schedule.
+     */
+    public static Block schedule(StartNode start) {
+        var scheduler = new Scheduler();
+        scheduler.doMarkAlive(start);
+        scheduler.doBuildCTF(start);
+        scheduler.doSchedule();
+        return scheduler.build(start);
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
new file mode 100644
index 00000000..af4305c0
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
@@ -0,0 +1,188 @@
+package com.seaofnodes.simple.fuzzer;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.Eval2;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.Node;
+import java.util.ArrayList;
+import java.util.Objects;
+import java.util.Random;
+import java.util.function.Consumer;
+
+/**
+ * Implementation of the fuzzer.
+ * Random testcases are generated using the ScriptGenerator.
+ * This will generate a script similar to how the parser parses it but instead of parsing it will
+ * randomly choose a variation the parser would parse and generate it.
+ * These scripts are the parsed by the parser and all exceptions are caught and filtered
+ * to only show one occurrence of one problem. This includes script which generate different
+ * results when graphs optimized with different worklist seeds are executed.
+ * To aid debugging scripts that cause errors are then reduced by applying rules and checking
+ * that the same issue persists.
+ */
+public class Fuzzer {
+
+    private static final int EVAL_TIMEOUT = 10000;
+
+    /**
+     * List of exceptions already encountered.
+     * This is used to filter new exceptions and discard them if they are already found.
+     */
+    private final ArrayList<Throwable> exceptions = new ArrayList<>();
+
+    /**
+     * Filter and record an exception in a script.
+     * @param e The exception caused by the script
+     * @param script The script causing the exception
+     * @param reproducer Reproducer which should be used to reproduce the test case.
+     */
+    private void recordException(Throwable e, String script, Consumer<String> reproducer, long seed) {
+        for (var ex : exceptions) {
+            if (FuzzerUtils.isExceptionFromSameCause(ex, e)) return;
+        }
+        exceptions.add(e);
+        System.out.println("========== Stack ==========");
+        e.printStackTrace(System.out);
+        System.out.println("========== Seed ==========");
+        System.out.println(seed);
+        //System.out.println("========== Code ===========");
+        //System.out.println(script);
+        System.out.println("========= Reduced =========");
+        System.out.println(Reducer.reduce(script, e, reproducer));
+        System.out.println("===========================");
+        System.out.flush();
+    }
+
+    private static boolean neq(Object a, Object b) {
+        if (Objects.equals(a, b)) return false;
+        return true;
+    }
+
+    /**
+     * Check that two graphs result in the same output when supplied with a value
+     * @param e1 Evaluator for the first graph
+     * @param e2 Evaluator for the second graph
+     * @param in The input value to both graphs to test for an equal output
+     */
+    private static void checkGraphs(CodeGen code1, CodeGen code2, long in) {
+        var r1 = Eval2.eval(code1, in, EVAL_TIMEOUT);
+        var r2 = Eval2.eval(code2, in, EVAL_TIMEOUT);
+        if( r1 == null || r2 == null ) return; // Timeout test invalid
+        if( neq(r1, r2) )
+            throw new RuntimeException("Different calculations values " + r1 + " vs " + r2);
+    }
+
+    /**
+     * Run checks for script. Compile the script with two different optimizer worklist seeds.
+     * Check that exceptions raised in the parser by both methods are the same and only happens if the script may be invalid.
+     * If the script was successfully parsed check that both version behave the same.
+     * @param script The script to test
+     * @param valid If the script is definitely valid. If not some exceptions may be suppressed.
+     */
+    private static void runCheck(String script, boolean valid) {
+        CodeGen code1;
+        try {
+            code1 = FuzzerUtils.parse(script, 123, true);
+        } catch (RuntimeException e1) {
+            try {
+                FuzzerUtils.parse(script, 456, false);
+            } catch (RuntimeException e2) {
+                if (FuzzerUtils.isExceptionFromSameCause(e1, e2)) {
+                    if (!valid || e1.getClass() == Parser.ParseException.class) return;
+                } else {
+                    e1.addSuppressed(e2);
+                }
+            }
+            throw e1;
+        }
+        CodeGen code2 = FuzzerUtils.parse(script, 456, false);
+        checkGraphs(code1, code2, 0);
+        checkGraphs(code1, code2, 1);
+        checkGraphs(code1, code2, 10);
+    }
+
+    /**
+     * Check that the script does not result in exceptions.
+     * @param script The script to test.
+     * @param valid If the script is valid or if it might contain syntax errors.
+     */
+    private void check(String script, boolean valid, long seed) {
+        try {
+            runCheck(script, valid);
+        } catch (Throwable e) {
+            recordException(e, script, s->runCheck(s, valid), seed);
+        }
+    }
+
+    /**
+     * Run one test with the given seed, and check for peephole counts.
+     * @param seed The seed to use for generating this test case
+     */
+    public int fuzzPeepTiming(long seed, int max_nids) {
+        var rand = new Random(seed);
+        var sb = new StringBuilder();
+        new ScriptGenerator(rand, sb, true).genProgram();
+        try {
+            var code = new CodeGen(sb.toString());
+
+            code.parse();
+            int nids = code.UID();
+            if( nids <= max_nids ) return max_nids; // Smaller, looking for trends as we grow
+            int parse_peeps= code._iter_cnt;
+            int parse_nops = code._iter_nop_cnt;
+            double parse_nop_ratio = (double)parse_nops/parse_peeps;
+            double parse_peeps_per_node = (double)parse_peeps/nids;
+
+            code.iter().opto().iterPostOpto().finalizeIR();
+            int iter_peeps= code._iter_cnt;
+            int iter_nops = code._iter_nop_cnt;
+            double iter_nop_ratio = (double)iter_nops/iter_peeps;
+            double iter_peeps_per_node = (double)iter_peeps/nids;
+
+            System.out.printf("%6d | Parsing: peeps: %5d, nops: %5d, ratio: %5.3f, last UID: %5d ps/node: %5.3f  | Iter: peeps: %6d, nops: %6d, ratio: %5.3f, ps/node: %5.3f\n",
+                              seed,
+                              parse_peeps,parse_nops,parse_nop_ratio,nids,parse_peeps_per_node,
+                              iter_peeps , iter_nops, iter_nop_ratio,      iter_peeps_per_node);
+            return nids;
+        } catch (Throwable e) {
+            // ignore exceptions, let the normal fullPeeps catch and reduce,
+            // we're interested in valid program optimizations
+        }
+        return max_nids;
+    }
+
+
+    /**
+     * Run one test with the given seed.
+     * @param seed The seed to use for generating this test case
+     */
+    public void fuzzPeeps(long seed) {
+        var rand = new Random(seed);
+        var sb = new StringBuilder();
+        var valid = new ScriptGenerator(rand, sb, true).genProgram();
+        check(sb.toString(), valid, seed);
+    }
+
+
+    /**
+     * Check that no exceptions happened.
+     * @return true if no exception happened
+     */
+    public boolean noExceptions() {
+        return exceptions.isEmpty();
+    }
+
+    /** Run a fixed chapter-local seed without reducing or swallowing failures. */
+    public void fuzzPeepsRegression(long seed) {
+        var rand = new Random(seed);
+        var sb = new StringBuilder();
+        var valid = new ScriptGenerator(rand, sb, true).genProgram();
+        try {
+            runCheck(sb.toString(), valid);
+        } catch (Throwable e) {
+            AssertionError ae = new AssertionError("Fuzzer regression seed failed: " + seed);
+            ae.initCause(e);
+            throw ae;
+        }
+    }
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
new file mode 100644
index 00000000..45558541
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
@@ -0,0 +1,111 @@
+package com.seaofnodes.simple.fuzzer;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.node.StopNode;
+import com.seaofnodes.simple.type.TypeInteger;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+import java.util.BitSet;
+
+/**
+ * Some utilities for the fuzzer.
+ */
+class FuzzerUtils {
+
+    /**
+     * Get the val of a private field
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException {
+        return (T) (obj instanceof Class<?> clz ? getField(clz, name).get(null) : getField(obj.getClass(), name).get(obj));
+    }
+
+    /**
+     * Get access to a private field
+     */
+    public static Field getField(Class<?> clz, String name) throws NoSuchFieldException {
+        var field = clz.getDeclaredField(name);
+        try {
+            field.setAccessible(true);
+        } catch (Throwable e) {
+            // Intentionally left empty
+        }
+        return field;
+    }
+
+    /**
+     * Try to rethrow an exception or create a runtime exception and throw it.
+     */
+    public static RuntimeException rethrow(Throwable e) {
+        if (e instanceof RuntimeException re) return re;
+        if (e instanceof Error er) throw er;
+        return new RuntimeException(e);
+    }
+
+    /**
+     * Some problems might trigger debug output. Suppress this output with a null print stream during fuzzing.
+     */
+    public static final PrintStream NULL_PRINT_STREAM = new PrintStream(OutputStream.nullOutputStream());
+
+    /**
+     * Check that the messages are similar.
+     */
+    private static boolean similarMessages(String a, String b) {
+        if (a == null || b == null) return true;
+        a = a.replaceAll("'\\w+'", "'normalized'").replaceAll("variable \\w+", "variable normalized");
+        b = b.replaceAll("'\\w+'", "'normalized'").replaceAll("variable \\w+", "variable normalized");
+        return a.equals(b);
+    }
+
+    /**
+     * Check if both stack traces have the same first entry. Empty stack traces can happen with NPE optimization
+     * and allow the other to be any stack trace.
+     */
+    private static boolean sameStackTraceOrigin(StackTraceElement[] a, StackTraceElement[] b) {
+        if (a == null || a.length == 0 || b == null || b.length == 0) return true; // One or both stack traces are missing.
+        return a[0].equals(b[0]);
+    }
+
+    /**
+     * Checks if two exceptions are caused by the same problem.
+     */
+    public static boolean isExceptionFromSameCause(Throwable a, Throwable b) {
+        if (a == null || b == null) return a == b; // Handle the null case
+        if (a.getClass() != b.getClass()) return false; // Different classes
+        if (!similarMessages(a.getMessage(), b.getMessage())) return false; // Different messages. Null is allowed as wildcard
+        var s1 = a.getStackTrace();
+        var s2 = b.getStackTrace();
+        if (!sameStackTraceOrigin(s1, s2)) return false; // Different stack trace origins
+        if (!isExceptionFromSameCause(a.getCause(), b.getCause())) return false; // Different causes
+        var o1 = a.getSuppressed();
+        var o2 = b.getSuppressed();
+        if (o1 == null || o2 == null || o1.length != o2.length) return o1 == o2; // Different suppression
+        for (int i=0; i<o1.length; i++) {
+            if (!isExceptionFromSameCause(o1[i], o2[i])) return false; // Different suppression
+        }
+        return true;
+    }
+
+    /**
+     * Parse and optimize using the given worklist seed
+     */
+    public static CodeGen parse(String script, long workListSeed, boolean reset) {
+        var err = System.err;
+        var out = System.out;
+        try {
+            System.setErr(NULL_PRINT_STREAM);
+            System.setOut(NULL_PRINT_STREAM);
+            var code = new CodeGen(script, TypeInteger.BOT, workListSeed, reset);
+            return code.driver(CodeGen.Phase.LocalSched);
+        } finally {
+            System.setErr(err);
+            System.setOut(out);
+        }
+    }
+
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
new file mode 100644
index 00000000..f6e12e11
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
@@ -0,0 +1,177 @@
+package com.seaofnodes.simple.fuzzer;
+
+import java.util.Arrays;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * This class is used to reduce test cases created by the fuzzer.
+ * It applies rewrite rules to the test case and checks that the
+ * test still produces the same exception.
+ * This is done in a fixpoint iteration until every rewrite produces
+ * no or a different exception.
+ */
+public class Reducer {
+
+    private interface Replacer extends BiConsumer<StringBuilder, Matcher> {}
+
+    /**
+     * Holder for the rewrite rules
+     */
+    private record Replace(Pattern pattern, boolean iterate, Replacer... replacements) {
+        Replace(Pattern p, Object... replacements) {
+            this(p, replacements[0] == Boolean.TRUE, Arrays.stream(replacements).filter(o->!(o instanceof Boolean)).map(Replace::from).toArray(Replacer[]::new));
+        }
+        private static Replacer from(Object o) {
+            if (o instanceof Replacer r) return r;
+            if (o instanceof Integer i) return (s, m)->s.append(m.group(i));
+            if (o instanceof String r) return (s, m)->s.append(r);
+            throw new IllegalArgumentException();
+        }
+    }
+
+    /**
+     * List of rewrite rules.
+     */
+    private static final Replace[] REPLACEMENTS = {
+            new Replace(Pattern.compile("\\b(?:[^\\W0]|\\w\\w+)\\b"), "0", "1"),
+            new Replace(Pattern.compile("(?<=\\n|^)[^\\n]+(?=\\n|$)"), true, ""),
+            new Replace(Pattern.compile("(?<=[+\\-*/<>=(])--"), ""),
+            new Replace(Pattern.compile("\\b--"), "+"),
+            new Replace(Pattern.compile("[-!]"), ""),
+            new Replace(Pattern.compile("\\b\\+-"), "-"),
+            new Replace(Pattern.compile("(?<![+\\-*/<>=&|])(?:-|\\*|/|>=|<=|>>>|>>|>|<<|<|!=|==|&&|\\|\\||&|\\||^)(?![+*/<>=&|])"), "+"),
+            new Replace(Pattern.compile("\\?([^;]+):"), "+"),
+            new Replace(Pattern.compile("\\{((?:[^{}]|\\{})+)(?:\\n[ \\t]*)?}"), "", "{}", 1),
+            new Replace(Pattern.compile("(?<=\\n|^)([ \\t]*)\\{\\n(.*?)\\n\\1}", Pattern.DOTALL), 2),
+            new Replace(Pattern.compile("\\(([^()]+)\\)"), 1),
+            new Replace(Pattern.compile("\\d+ ?\\+ ?"), ""),
+            new Replace(Pattern.compile(" ?\\+ ?\\d+"), ""),
+            new Replace(Pattern.compile("\\n\\n+"), "\n"),
+            new Replace(Pattern.compile("^\\n+|\\n+$"), ""),
+            new Replace(Pattern.compile("else *"), ""),
+            new Replace(Pattern.compile("\\bif\\([^()]+\\) *"), ""),
+            new Replace(Pattern.compile("\\bwhile\\([^()]+\\) *"), ""),
+            new Replace(Pattern.compile("\\bstruct \\w+ \\{[^{}]*}"), "")
+    };
+
+    /**
+     * Predicate to test if the reduced script generates the same error.
+     */
+    private final Predicate<String> tester;
+
+    /**
+     * Create a reducer with a test function.
+     * @param tester Test function which returns true when the same issue is found in the script.
+     */
+    private Reducer(Predicate<String> tester) {
+        this.tester = tester;
+    }
+
+    /**
+     * Rewrites the script with one rewrite rule.
+     */
+    private String doReplacement(String script, Pattern pattern, Replacer[] replacements) {
+        var matcher = pattern.matcher(script);
+        var sb = new StringBuilder();
+        var last = 0;
+        var skip = 0;
+        outer:
+        while (matcher.find(last + skip)) {
+            sb.append(script, last, matcher.start());
+            last = matcher.end();
+            skip = last == matcher.start() ? 1 : 0;
+            var pos = sb.length();
+            for (var replacement : replacements) {
+                replacement.accept(sb, matcher);
+                var tail = sb.length();
+                sb.append(script, last, script.length());
+                if (tester.test(sb.toString())) {
+                    sb.setLength(tail);
+                    continue outer;
+                }
+                sb.setLength(pos);
+            }
+            last = matcher.start();
+            skip = 1;
+        }
+        sb.append(script, last, script.length());
+        return sb.toString();
+    }
+
+    /**
+     * Clean up variable names from the random ones generated by the fuzzer.
+     */
+    private String cleanVariables(String script) {
+        var matcher = Pattern.compile("\\b([0-9a-zA-Z_]+) !?([0-9a-zA-Z_]+)").matcher(script);
+        int[] num = {0, 0};
+        while (matcher.find()) {
+            var type = matcher.group(1);
+            var var = matcher.group(2);
+            if (type.equals("new")) continue;
+            String prefix = "v";
+            int t = 0;
+            if (type.equals("struct")) {
+                t = 1;
+                prefix = "s";
+            }
+            if (var.matches(prefix+"\\d+")) continue;
+            while (script.contains(prefix+num[t])) num[t]++;
+            var n = script.replaceAll("\\b"+var+"\\b", prefix + num[t]);
+            if (tester.test(n)) {
+                script = n;
+            }
+        }
+        return script;
+    }
+
+    /**
+     * Run all rewrite rules once.
+     */
+    private String doAllReplacements(String script) {
+        for (var replace: REPLACEMENTS) {
+            String old;
+            do {
+                old = script;
+                script = doReplacement(script, replace.pattern, replace.replacements);
+            } while (replace.iterate && !old.equals(script));
+        }
+        return script;
+    }
+
+    /**
+     * Reduce the script to a minimal version which produces the same problem with a test function.
+     * @param tester Test function which returns true when the same issue is found in the script.
+     */
+    public static String reduce(String script, Predicate<String> tester) {
+        var reducer = new Reducer(tester);
+        String old;
+        do {
+            old = script;
+            script = reducer.doAllReplacements(script);
+            script = reducer.cleanVariables(script);
+        } while (!script.equals(old));
+        return script;
+    }
+
+    /**
+     * Reduce the script to a minimal version which produces the same problem with a reproducer.
+     * @param ex The exception originally caused by the script
+     * @param reproducer Test function which throws an exception which will be checked against ex.
+     */
+    public static String reduce(String script, Throwable ex, Consumer<String> reproducer) {
+        return reduce(script, s->{
+            Throwable nex = null;
+            try {
+                reproducer.accept(s);
+            } catch (Throwable e) {
+                nex = e;
+            }
+            return FuzzerUtils.isExceptionFromSameCause(nex, ex);
+        });
+    }
+
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
new file mode 100644
index 00000000..20815d5d
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
@@ -0,0 +1,940 @@
+package com.seaofnodes.simple.fuzzer;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.node.ScopeNode;
+import com.seaofnodes.simple.type.TypeInteger;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Predicate;
+import static com.seaofnodes.simple.Parser.KEYWORDS;
+
+
+/**
+ * Generate a pseudo random script.
+ * This generator will generate the same script for two random number generators initialized with the same seed.
+ * To generate valid code it implements the parser but instead of parsing it emits the statements and expressions.
+ * It is guaranteed to terminate.
+ */
+public class ScriptGenerator {
+
+    private static final int MAX_STATEMENTS_PER_BLOCK = 5;
+    private static final int MAX_NAME_LENGTH = 10;
+    private static final int MAX_BLOCK_DEPTH = 4;
+    private static final int MAX_EXPRESSION_DEPTH = 10;
+
+    /**
+     * Number of spaces per indentation
+     */
+    private static final int INDENTATION = 4;
+    /**
+     * Valid characters for identifiers. The last 10 are not valid for the first character.
+     */
+    private static final String VAR_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789";
+
+    /**
+     * Flag for a statement that it does not pass on control flow to the next statement.
+     */
+    private static final int FLAG_STOP = 0x01;
+    /**
+     * Flag for a statement that it contains a final if statement without an else branch.
+     */
+    private static final int FLAG_IF_WITHOUT_ELSE = 0x02;
+
+    private static class Type {
+        final String name;
+        Type(String name) {this.name=name;}
+        boolean isa(Type other) { return this == other; }
+    }
+
+    private static class TypeStruct extends Type {
+        record Field (String name, Type type, TypeStruct struct) {}
+        Field[] fields;
+        final TypeNullable nullable = new TypeNullable(this);
+        TypeStruct(String name) {
+            super(name);
+        }
+        boolean isa(Type other) { return this == other || other == nullable; }
+    }
+
+    private static class TypeNullable extends Type {
+
+        final Type base;
+
+        TypeNullable(Type base) {
+            super(base.name+"?");
+            this.base = base;
+        }
+
+    }
+
+    private static final Type TYPE_FLT = new Type("flt");
+
+    private static class TypeInt extends Type {
+
+        TypeInt(String name) {
+            super(name);
+        }
+
+        @Override
+        boolean isa(Type other) {
+            return super.isa(other) || other == TYPE_FLT || other instanceof TypeInt;
+        }
+    }
+
+    private static final List<TypeInt> INTTYPES = new ArrayList<>();
+
+    static {
+        for( var e : Parser.TYPES.entrySet() ) {
+            if( e.getValue() instanceof TypeInteger ) {
+                INTTYPES.add(new TypeInt(e.getKey()));
+            }
+        }
+    }
+
+    private static final Type TYPE_INT = INTTYPES.stream().filter(t->t.name.equals("int")).findAny().get();
+    private static final Type TYPE_BOOL = INTTYPES.stream().filter(t->t.name.equals("bool")).findAny().get();
+
+    private static class Variable {
+        final String name;
+        final Type declared;
+        final Variable shadowing;
+        Type type;
+        boolean shadowed = false;
+
+        Variable(String name, Type type, Variable var) {
+            this.name = name;
+            this.declared = type;
+            this.type = type;
+            this.shadowing = var;
+        }
+    }
+
+    /**
+     * The random number generator used for random decisions.
+     */
+    private final Random random;
+    /**
+     * Indentation depth.
+     */
+    private int indentation = 0;
+    /**
+     * Output string builder
+     */
+    private final StringBuilder sb;
+    /**
+     * Number of nested loops
+     */
+    private int loopDepth = 0;
+    /**
+     * Current scope start in the variables list.
+     */
+    private int currScopeStart = 0;
+    /**
+     * The depth of blocks allowed.
+     */
+    private int depth = MAX_BLOCK_DEPTH;
+    /**
+     * Current variables in scope.
+     */
+    private final ArrayList<Variable> variables = new ArrayList<>();
+    /**
+     * All defined structs.
+     */
+    private final ArrayList<TypeStruct> structs = new ArrayList<>();
+    /**
+     * All forward declared structs
+     */
+    private final ArrayList<TypeStruct> forwardStructs = new ArrayList<>();
+    /**
+     * Allow to declare structs.
+     */
+    private boolean allowStructs = true;
+    /**
+     * If this needs to generate valid scripts or is also allowed to generate invalid ones.
+     */
+    private boolean generateValid;
+    /**
+     * If this script might be invalid.
+     */
+    private boolean maybeInvalid = false;
+
+
+    /**
+     *
+     * @param random the random number generator.
+     * @param sb the script will be written to this string builder.
+     * @param generateValid if the script should be guaranteed valid or if it is allowed to contain bugs.
+     */
+    public ScriptGenerator(Random random, StringBuilder sb, boolean generateValid) {
+        this.random = random;
+        this.sb = sb;
+        this.generateValid = generateValid;
+    }
+
+    /**
+     * Random number with log distribution
+     * @param max The maximum value
+     * @return A random number in the range [0, max) with higher numbers being more uncommon.
+     */
+    private int randLog(int max) {
+        max--;
+        int n = 1<<max;
+        var num = random.nextInt(n);
+        for (int i=max-1; i>=0; i--) {
+            if ((num & (1<<i))!=0) return max-i-1;
+        }
+        return max;
+    }
+
+    /**
+     * Helper function to print indentation.
+     * @return sb for chaining
+     */
+    private StringBuilder printIndentation() {
+        return sb.repeat(' ', indentation);
+    }
+
+    /**
+     * Generate a random name for variables. This might be invalid when it is a keyword.
+     * @return The random name generated
+     */
+    private StringBuilder getRandomName() {
+        int len = random.nextInt(MAX_NAME_LENGTH) + 1;
+        StringBuilder sb = new StringBuilder(len);
+        sb.append(VAR_CHARS.charAt(random.nextInt(VAR_CHARS.length()-10)));
+        for (int i=1; i<len; i++)
+            sb.append(VAR_CHARS.charAt(random.nextInt(VAR_CHARS.length())));
+        return sb;
+    }
+
+    /**
+     * Should invalid code be generated?
+     * @return True if invalid code should be generated
+     */
+    private boolean generateInvalid() {
+        if (generateValid || random.nextInt(1000)>2) return false;
+        maybeInvalid = true;
+        return true;
+    }
+
+    /**
+     * Lookup a variable by name
+     * @param name name of the variable
+     * @return The index of the variable in variables or -1
+     */
+    private int lookup(String name) {
+        for (int i=variables.size()-1; i>=0; i--) {
+            if (variables.get(i).name.equals(name)) return i;
+        }
+        return -1;
+    }
+
+    /**
+     * Lookup a variable by name
+     * @param name name of the variable
+     * @return THe variable of null if not found
+     */
+    private Variable lookupVar(String name) {
+        int idx = lookup(name);
+        return idx == -1 ? null : variables.get(idx);
+    }
+
+    /**
+     * Add a variable to the current scope
+     * @param name The name of the variable
+     * @param type The declared type of the variable
+     */
+    private void addVariable(String name, Type type) {
+        var old = lookupVar(name);
+        variables.add(new Variable(name, type, old));
+        if (old != null) old.shadowed = true;
+    }
+
+    /**
+     * Pop variables to level to
+     * @param to Level until which variables should be popped
+     */
+    private void popVariables(int to) {
+        while (variables.size() > to) {
+            var v = variables.removeLast();
+            if (v.shadowing != null) v.shadowing.shadowed = false;
+        }
+    }
+
+    /**
+     * Get a random visible variable patching pred
+     * @param pred The predicate the variable needs to match
+     * @return A random visible variable matching pred or null if no variable mached pred.
+     */
+    private Variable findVisibleVariablesMatching(Predicate<Variable> pred) {
+        int num=0;
+        for (var v:variables) {
+            if (!v.shadowed && pred.test(v)) num++;
+        }
+        if (num == 0) return null;
+        num = random.nextInt(num);
+        for (var v:variables) {
+            if (!v.shadowed && pred.test(v) && num-- == 0) return v;
+        }
+        throw new AssertionError();
+    }
+
+    /**
+     * Get a structure by name
+     * @param name Name of the structure
+     * @return The structure of null
+     */
+    private TypeStruct getStruct(String name) {
+        for (var s:structs) {
+            if (s.name.equals(name)) return s;
+        }
+        for (var s:forwardStructs) if (s.name.equals(name)) return s;
+        return null;
+    }
+
+    /**
+     * Generate a variable name. This might be new random name or a name from an outer scope.
+     * If the program is allowed to be invalid this can return keywords and already used variable names in the current scope.
+     * @return The variable name.
+     */
+    private String getVarName() {
+        if (currScopeStart > 0 && random.nextInt(10) > 7) {
+            // Use a variable outside the current scope.
+            var v = variables.get(random.nextInt(currScopeStart));
+            if (lookup(v.name) < currScopeStart) return v.name;
+            if (!generateValid) {
+                maybeInvalid = true;
+                return v.name;
+            }
+        }
+        // Generate a new random variable name
+        StringBuilder sb = getRandomName();
+        var v = sb.toString();
+        if (!generateValid && (KEYWORDS.contains(v) || lookup(v) >= currScopeStart)) {
+            maybeInvalid = true;
+            return v;
+        }
+        while (KEYWORDS.contains(v) || lookup(v) >= currScopeStart) {
+            sb.append(VAR_CHARS.charAt(random.nextInt(VAR_CHARS.length())));
+            v = sb.toString();
+        }
+        return v;
+    }
+
+    private <T> T randFromList(List<T> list) {
+        return list.get(random.nextInt(list.size()));
+    }
+
+    /**
+     * Get a random structure name
+     * @return A random structure name
+     */
+    private String getStructName() {
+        if (!structs.isEmpty() && generateInvalid()) return randFromList(structs).name;
+        if (!forwardStructs.isEmpty() && generateInvalid()) return randFromList(forwardStructs).name;
+
+        // Generate a new random struct name
+        StringBuilder sb = getRandomName();
+        var v = sb.toString();
+        if (!generateValid && (KEYWORDS.contains(v) || getStruct(v) != null)) {
+            maybeInvalid = true;
+            return v;
+        }
+        while (KEYWORDS.contains(v) || getStruct(v) != null) {
+            sb.append(VAR_CHARS.charAt(random.nextInt(VAR_CHARS.length())));
+            v = sb.toString();
+        }
+        return v;
+    }
+
+    public TypeInt getIntType() {
+        return randFromList(INTTYPES);
+    }
+
+    /**
+     * Get a random type
+     * @return A random type
+     */
+    private Type getType(boolean allowForward) {
+        int t = random.nextInt(10);
+        if( t<5 || structs.isEmpty() ) return getIntType();
+        if( t<7 ) return TYPE_FLT;
+        if (allowForward && random.nextInt(10)==0) {
+            int i=random.nextInt(forwardStructs.size()+1);
+            if (i>0) return forwardStructs.get(i-1).nullable;
+            var name = getStructName();
+            var struct = new TypeStruct(name);
+            forwardStructs.add(struct);
+            return struct.nullable;
+        }
+        TypeStruct struct = randFromList(structs);
+        if (random.nextBoolean()) return struct.nullable;
+        return struct;
+    }
+
+    private Type getType() {
+        return getType(false);
+    }
+
+    /**
+     * Generates a program and writes it into the string builder supplied in the constructor.
+     * @return If the program is allowed to be invalid returns if something potentially invalid was generated.
+     */
+    public boolean genProgram() {
+        var oldGenerateValid = generateValid;
+        if (!generateValid && random.nextBoolean()) generateValid = true;
+        this.maybeInvalid = false;
+        addVariable(ScopeNode.ARG0, TYPE_INT);
+        currScopeStart = variables.size();
+        if ((genStatements() & FLAG_STOP) == 0) {
+            if (generateValid || random.nextInt(10)<7) {
+                genReturn();
+            } else {
+                this.maybeInvalid = true;
+            }
+        }
+        generateValid = oldGenerateValid;
+        return !this.maybeInvalid;
+    }
+
+    /**
+     * Generate a list of statements.
+     * @return flags FLAG_STOP and FLAG_IF_WITHOUT_ELSE for the last statement generated
+     */
+    public int genStatements() {
+        var num = random.nextInt(MAX_STATEMENTS_PER_BLOCK * (depth+1));
+        for (int i=0; i<num; i++) {
+            printIndentation();
+            var stop = genStatement();
+            sb.append("\n");
+            if ((stop & FLAG_STOP) != 0) return stop;
+        }
+        return 0;
+    }
+
+    /**
+     * Generate a single statement
+     * @return flags FLAG_STOP and FLAG_IF_WITHOUT_ELSE for the generated statement
+     */
+    public int genStatement() {
+        return switch (random.nextInt(12)) {
+            case 0 -> allowStructs || generateInvalid() ? genStruct() : genAssignment();
+            case 1 -> genBlock();
+            case 2 -> genIf();
+            case 3 -> genCountedLoop();
+            case 4 -> genWhile();
+            case 5, 6 -> genDecl();
+            case 7, 8, 9 -> genAssignment();
+            case 10 -> genNullCheck();
+            default -> genExit();
+        };
+    }
+
+    /**
+     * Generate a new structure
+     * @return 0
+     */
+    public int genStruct() {
+        int idx = random.nextInt(forwardStructs.size()+10);
+        TypeStruct struct;
+        if (idx < 10) {
+            var name = getStructName();
+            struct = new TypeStruct(name);
+            forwardStructs.add(struct);
+        } else {
+            struct = forwardStructs.get(idx-10);
+        }
+        var fields = new TypeStruct.Field[generateInvalid() ? 0 : random.nextInt(10)];
+        sb.append("struct ").append(struct.name).append(" {\n");
+        indentation += INDENTATION;
+        for (int i=0; i<fields.length; i++) {
+            var fieldName = getRandomName();
+            var type = getType(true);
+            printIndentation().append(declType(type)).append(" !").append(fieldName).append(";\n");
+            fields[i] = new TypeStruct.Field(fieldName.toString(), type, struct);
+        }
+        indentation -= INDENTATION;
+        printIndentation().append("};");
+        struct.fields = fields;
+        forwardStructs.remove(struct);
+        structs.add(struct);
+        return 0;
+    }
+
+    /**
+     * Generate a statement for if, else and while blocks.
+     * This is special since it disallows declarations and prefers to generate blocks.
+     * @return flags FLAG_STOP and FLAG_IF_WITHOUT_ELSE for the generated statement
+     */
+    public int genStatementBlock() {
+        var oldAllowStructs = allowStructs;
+        allowStructs = false;
+        indentation += INDENTATION;
+        int res;
+        if (depth == 0) {
+            res = random.nextBoolean() ? genAssignment() : genExit();
+        } else {
+            depth--;
+            res = switch (random.nextInt(12)) {
+                case 1, 2, 3, 4, 5 -> {
+                    depth++;
+                    indentation -= INDENTATION;
+                    var ret = genBlock();
+                    indentation += INDENTATION;
+                    depth--;
+                    yield ret;
+                }
+                case 6 -> genIf();
+                case 7 -> genCountedLoop();
+                case 8 -> genWhile();
+                case 9 -> genAssignment();
+                case 10 -> genNullCheck();
+                default -> genExit();
+            };
+            depth++;
+        }
+        indentation -= INDENTATION;
+        allowStructs = oldAllowStructs;
+        return res;
+    }
+
+    /**
+     * Generate an exit. This can be return or break and continue when in a loop.
+     * @return FLAG_STOP
+     */
+    public int genExit() {
+        if (loopDepth == 0 && generateValid) return genReturn();
+        return switch (random.nextInt(7)) {
+            case 0,1,2 -> {
+                if (loopDepth == 0) maybeInvalid = true;
+                sb.append("continue;");
+                yield FLAG_STOP;
+            }
+            case 3,4,5 -> {
+                if (loopDepth == 0) maybeInvalid = true;
+                sb.append("break;");
+                yield FLAG_STOP;
+            }
+            default -> genReturn();
+        };
+    }
+
+    /**
+     * Generate a block statement. After a certain depth only empty blocks are generated to ensure termination of the generator.
+     * @return flag FLAG_STOP for the generated statement
+     */
+    public int genBlock() {
+        if (depth == 0) {
+            sb.append("{}");
+            return 0;
+        }
+        var oldAllowStructs = allowStructs;
+        var oldCSS = currScopeStart;
+        allowStructs = false;
+        currScopeStart = variables.size();
+        depth--;
+        sb.append("{\n");
+        indentation += INDENTATION;
+        var stop = genStatements();
+        indentation -= INDENTATION;
+        printIndentation().append("}");
+        popVariables(currScopeStart);
+        depth++;
+        currScopeStart = oldCSS;
+        allowStructs = oldAllowStructs;
+        return stop & ~FLAG_IF_WITHOUT_ELSE;
+    }
+
+    /**
+     * Generate an if statement with an optional else block.
+     * @return flags FLAG_STOP and FLAG_IF_WITHOUT_ELSE for the generated statement
+     */
+    public int genIf() {
+        sb.append("if(");
+        genExpression(TYPE_BOOL, true, true);
+        sb.append(") ");
+        var stop = genStatementBlock();
+        if ((stop & FLAG_IF_WITHOUT_ELSE) == 0 && random.nextInt(10) > 3) {
+            sb.append("\n");
+            printIndentation().append("else ");
+            stop &= genStatementBlock();
+        } else {
+            stop = FLAG_IF_WITHOUT_ELSE;
+        }
+        return stop;
+    }
+
+    /**
+     * Generate a block with a null check
+     * if (nullable) { handle_nullable_as_non_nullable; }
+     */
+    public int genNullCheck() {
+        var v = findVisibleVariablesMatching(va->va.declared instanceof TypeNullable);
+        if (v == null) return genIf();
+        var n = (TypeNullable)v.declared;
+        boolean negate = random.nextBoolean();
+        sb.append("if(");
+        if (negate) sb.append("!");
+        sb.append(v.name).append(")");
+        if (!negate) v.type = n.base;
+        var stop = genStatementBlock();
+        v.type = n;
+        if ((stop & FLAG_IF_WITHOUT_ELSE) == 0 && random.nextInt(10) > 3) {
+            sb.append("\n");
+            printIndentation().append("else ");
+            if (negate) v.type = n.base;
+            stop &= genStatementBlock();
+            v.type = n;
+        } else {
+            stop = FLAG_IF_WITHOUT_ELSE;
+        }
+        return stop;
+    }
+
+    /**
+     * Generate a while loop.
+     * @return 0
+     */
+    public int genWhile() {
+        sb.append("while(");
+        genExpression(TYPE_BOOL, true, true);
+        sb.append(") ");
+        loopDepth++;
+        genStatementBlock();
+        loopDepth--;
+        return 0;
+    }
+
+    /**
+     * Generate a counted loop of the form
+     * <code>
+     *     {
+     *         int varname = start_expr;
+     *         while (varname < end_expr) loop_body;
+     *     }
+     * </code>
+     * @return 0
+     */
+    public int genCountedLoop() {
+        if (depth == 0) return genWhile();
+        var oldCSS = currScopeStart;
+        currScopeStart = variables.size();
+        sb.append("{\n");
+        indentation += INDENTATION;
+        String name = getVarName();
+        printIndentation().append("int ").append(name).append("=");
+        genExpression(TYPE_INT, true, false);
+        sb.append(";\n");
+        addVariable(name, TYPE_INT);
+        printIndentation().append("while(").append(name).append("<");
+        genShift(TYPE_INT, true, false, MAX_EXPRESSION_DEPTH);
+        sb.append(") {\n");
+        indentation += INDENTATION;
+        depth--;
+        loopDepth++;
+        printIndentation().append(name).append("=").append(name).append("+");
+        genExpression(TYPE_INT, true, false);
+        sb.append(";\n");
+        genStatements();
+        loopDepth--;
+        depth++;
+        indentation -= INDENTATION;
+        printIndentation().append("}\n");
+        indentation -= INDENTATION;
+        printIndentation().append("}");
+        popVariables(currScopeStart);
+        currScopeStart = oldCSS;
+        return 0;
+    }
+
+    // This generator mutates references and fields; request both permissions.
+    private static String declType(Type type) {
+        return (type instanceof TypeStruct || type instanceof TypeNullable ? "!" : "") + type.name;
+    }
+
+    /** Generate a declaration statement. */
+    public int genDecl() {
+        var type = getType();
+        var name = getVarName();
+        // Always make them mutable
+        sb.append(generateInvalid() ? getRandomName() : declType(type)).append(" !").append(name);
+        if (!(type instanceof TypeNullable) || random.nextBoolean()) {
+            sb.append("=");
+            genExpression(type, true, type==TYPE_BOOL);
+        }
+        sb.append(";");
+        addVariable(name, type);
+        return 0;
+    }
+
+    /**
+     * Generate an assignment statement.
+     * @return 0
+     */
+    public int genAssignment() {
+        Type type;
+        Type declared;
+        if (generateInvalid()) {
+            sb.append(getRandomName());
+            type = getType();
+            declared = type;
+        } else {
+            var v = findVisibleVariablesMatching(va->true);
+            if (v == null) return genDecl();
+            sb.append(v.name);
+            type = v.type;
+            declared = v.declared;
+        }
+        if (generateInvalid()) {
+            var name = getRandomName();
+            sb.append(".").append(name);
+            declared = getType();
+        } else if (type instanceof TypeStruct s && s.fields.length > 0 && random.nextBoolean()) {
+            var field = s.fields[random.nextInt(s.fields.length)];
+            sb.append(".").append(field.name);
+            declared = field.type;
+        }
+        sb.append("=");
+        genExpression(declared, true, declared==TYPE_BOOL);
+        sb.append(";");
+        return 0;
+    }
+
+    /**
+     * Generate a return statement.
+     * @return FLAG_STOP
+     */
+    public int genReturn() {
+        var type = getType();
+        sb.append("return ");
+        genExpression(type, true, false);
+        sb.append(";");
+        return FLAG_STOP;
+    }
+
+    public void genExpression(Type type, boolean change, boolean preferLogical) {
+        genExpression(type, change, preferLogical, MAX_EXPRESSION_DEPTH);
+    }
+
+    public void genExpression(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        if (d > 0 && random.nextInt(10)==0) {
+            genLogical(TYPE_INT, true, true, d);
+            sb.append("?");
+            genExpression(type, true, preferLogical, d-1);
+            sb.append(":");
+            genExpression(type, false, preferLogical, d-1);
+        } else {
+            genLogical(type, false, preferLogical, d);
+        }
+    }
+
+    public void genLogical(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        genBitwise(type, false, preferLogical, d);
+        while (d-->0 && random.nextInt(preferLogical?5:50) == 0) {
+            sb.append(random.nextBoolean()?"&&":"||");
+            genBitwise(type, true, preferLogical, d);
+        }
+    }
+
+    public void genBitwise(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        genComparison(type, false, preferLogical, d);
+        while (type instanceof TypeInt && d-->0 && random.nextInt(preferLogical?50:5)==0) {
+            sb.append("&|^".charAt(random.nextInt(3)));
+            genComparison(type, true, preferLogical, d);
+        }
+    }
+
+    public void genComparison(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        if (d > 0 && type instanceof TypeInt && random.nextInt(preferLogical?5:50)==0) {
+            type = getType();
+            genComparison(type, true, preferLogical, d-1);
+            sb.append(random.nextBoolean()?"==":"!=");
+        }
+        genChaining(type, false, preferLogical, d);
+    }
+
+    public void genChaining(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        if (d>0 && type instanceof TypeInt && random.nextInt(preferLogical?5:50)==0) {
+            genShift(TYPE_INT, true, false, d);
+            char c = random.nextBoolean()?'>':'<';
+            sb.append(c);
+            if (random.nextInt(4)==0) sb.append('=');
+            genShift(TYPE_INT, true, false, --d);
+            while (d-->0 && random.nextInt(preferLogical?5:50)==0) {
+                if (generateInvalid()) c = c=='>' ? '<' : '>';
+                sb.append(c);
+                if (random.nextInt(4)==0) sb.append('=');
+                genShift(TYPE_INT, true, false, d);
+            }
+        } else {
+            genShift(type, false, preferLogical, d);
+        }
+    }
+
+    private static final String[] SHIFTS = {">>", ">>>", "<<"};
+
+    public void genShift(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        genAddition(type, false, preferLogical, d);
+        while (d-- > 0 && type instanceof TypeInt && random.nextInt(50)==0) {
+            sb.append(SHIFTS[random.nextInt(3)]);
+            genAddition(type, true, preferLogical, d);
+        }
+    }
+
+    public void genAddition(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        genMultiplication(type, false, preferLogical, d);
+        while (d-- > 0 && (type instanceof TypeInt || type==TYPE_FLT) && random.nextInt(50)==0) {
+            sb.append(random.nextBoolean()?" + ":" - ");
+            genMultiplication(type, true, preferLogical, d);
+        }
+    }
+
+    public void genMultiplication(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        genUnary(type, false, preferLogical, d);
+        while (d-- > 0 && (type instanceof TypeInt || type==TYPE_FLT) && random.nextInt(50)==0) {
+            sb.append(random.nextBoolean()?'*':'/');
+            genUnary(type, true, preferLogical, d);
+        }
+    }
+
+    /**
+     * Generate a unary expression.
+     */
+    public void genUnary(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        if (!(type instanceof TypeInt) && type != TYPE_FLT) {
+            genSuffix(type, false, preferLogical, d);
+            return;
+        }
+        while (d>0 && random.nextInt(5)==0) {
+            d--;
+            boolean what = type instanceof TypeInt && random.nextInt(preferLogical?2:20) == 0;
+            sb.append(what?'!':'-');
+        }
+        if (random.nextInt(10)==0) {
+            var t = type;
+            var v = findVisibleVariablesMatching(va->va.type.isa(t));
+            if (v != null) {
+                sb.append(random.nextBoolean()?"--":"++").append(v.name);
+                return;
+            }
+        }
+        genSuffix(type, false, preferLogical, d);
+    }
+
+    public TypeStruct.Field getField(Type type) {
+        int n=0;
+        for (var s: structs) {
+            for (var f: s.fields) {
+                if (f.type.isa(type)) n++;
+            }
+        }
+        if (n==0) return null;
+        n = random.nextInt(n);
+        for (var s: structs) {
+            for (var f: s.fields) {
+                if (f.type.isa(type)) if (n--==0) return f;
+            }
+        }
+        throw new AssertionError();
+    }
+
+    public void genSuffix(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        if (d > 0 && random.nextBoolean() && genField(type, d-1)) return;
+        if (d > 0 && random.nextInt(10) == 0) {
+            if (random.nextBoolean() && genField(type, d-1)) return;
+            var t = type;
+            var v = findVisibleVariablesMatching(va -> va.type.isa(t));
+            if (v != null) {
+                sb.append(v.name).append(random.nextBoolean() ? "--" : "++");
+                return;
+            }
+        }
+        genPrimary(type, false, preferLogical, d);
+    }
+
+    public boolean genField(Type type, int d) {
+        if (generateInvalid()) {
+            var field = getRandomName();
+            var t = getType();
+            genSuffix(t, true, false, d);
+            sb.append(".").append(field);
+        } else {
+            var field = getField(type);
+            if (field == null) return false;
+            genSuffix(field.struct, true, false, d);
+            sb.append(".").append(field.name);
+        }
+        return true;
+    }
+
+    /**
+     * Generate a primary expression.
+     */
+    public void genPrimary(Type type, boolean change, boolean preferLogical, int d) {
+        if (change && generateInvalid()) type = getType();
+        var rand = random.nextInt(10);
+        if (d > 0 && rand == 0) {
+            sb.append("(");
+            genExpression(type, false, preferLogical, d-1);
+            sb.append(")");
+        } else if (rand < 6) {
+            genVariable(type);
+        } else {
+            genConst(type);
+        }
+    }
+
+    /**
+     * Generate a constant.
+     */
+    public void genConst(Type type) {
+        if (generateInvalid()) type = getType();
+        if (type instanceof TypeInt || (type == TYPE_FLT && random.nextBoolean())) {
+            var rand = random.nextInt(10);
+            switch (rand) {
+                case 0 -> sb.append("true");
+                case 1 -> sb.append("false");
+                default -> sb.append(random.nextInt(1<<(rand-2)));
+            }
+        } else if (type == TYPE_FLT) {
+            sb.append(random.nextFloat());
+        } else if (type instanceof TypeNullable n) {
+            if ((n.base instanceof TypeStruct s && s.fields == null) || random.nextBoolean()) {
+                sb.append("null");
+            } else {
+                sb.append("new ").append(generateInvalid() ? getRandomName() : n.base.name);
+            }
+        } else {
+            sb.append("new ").append(generateInvalid() ? getRandomName() : type.name);
+        }
+    }
+
+    /**
+     * Generate a variable. If there are none generate a number instead.
+     * If the program is allowed to be invalid a random name can be generated in some cases.
+     */
+    public void genVariable(Type type) {
+        if (generateInvalid()) {
+            sb.append(getRandomName());
+            return;
+        }
+        if (generateInvalid()) type = getType();
+        var t = type;
+        var v = findVisibleVariablesMatching(va->va.type.isa(t));
+        if (v == null) genConst(type);
+        else sb.append(v.name);
+    }
+
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/arg_count.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/arg_count.c
new file mode 100644
index 00000000..e247e28a
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/arg_count.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+__attribute__ ((CALL_CONV))
+extern double addAll( long long i0, double f1, long long i2, double f3, long long i4, double f5, long long i6, double f7, long long i8, double f9, long long i10, double f11, long long i12, double f13, long long i14, double f15, long long i16, double f17, long long i18, double f19 );
+
+int main() {
+  double result = addAll( 0, 1.1, 2, 3.1, 4, 5.1, 6, 7.1, 8, 9.1, 10, 11.1, 12, 13.1, 14, 15.1, 16, 17.1, 18, 19.1 );
+  printf("%f\n", result);
+  return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/arg_count.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/arg_count.smp
new file mode 100644
index 00000000..6b6bc0ae
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/arg_count.smp
@@ -0,0 +1,6 @@
+// -*- mode: java;  -*-
+val addAll = { int i0, flt f1, int i2, flt f3, int i4, flt f5, int i6, flt f7, int x8, flt f9, int i10, flt f11, int i12, flt f13, int i14, flt f15, int x16, flt f17 int x18, flt f19 ->
+    return
+    i0 + f1+ i2+ f3+ i4+ f5+ i6+ f7+ x8 +f9 +
+    i10+f11+i12+f13+i14+f15+x16+f17+x18+f19 ;
+};
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/array1.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/array1.smp
new file mode 100644
index 00000000..6b10f92c
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/array1.smp
@@ -0,0 +1,9 @@
+// -*- mode: java;  -*-
+int[] !ary = new int[arg];
+// Fill [0,1,2,3,4,...]
+for( int i=0; i<ary#; i++ )
+    ary[i] = i;
+// Fill [0,1,3,6,10,...]
+for( int i=0; i<ary#-1; i++ )
+    ary[i+1] += ary[i];
+return ary[1] * 1000 + ary[3]; // 1 * 1000 + 6
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/brain_fuck.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/brain_fuck.c
new file mode 100644
index 00000000..127cbe73
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/brain_fuck.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+typedef struct AryInt {
+    unsigned int len;
+    unsigned char data[];
+} AryInt;
+
+__attribute__ ((CALL_CONV))
+extern AryInt* brain_fuck();
+
+int main() {
+  AryInt* ps = brain_fuck();
+
+  printf("%.*s", ps->len, ps->data);
+
+  return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/c_returns.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/c_returns.c
new file mode 100644
index 00000000..6d0ff2fe
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/c_returns.c
@@ -0,0 +1,28 @@
+#include <stdint.h>
+#include <stdio.h>
+
+uint64_t c_bits;
+// Legal narrow C returns: unused RAX bits deliberately contain garbage.
+#define RET(name) __asm__(".text\n.globl " #name "\n" #name ":\nmovq c_bits(%rip), %rax\nret\n");
+RET(c_i8) RET(c_u8) RET(c_i16) RET(c_u16) RET(c_i32) RET(c_u32) RET(c_i64)
+#define DECL(name) extern int64_t __attribute__((CALL_CONV)) name(void);
+DECL(test_i8) DECL(test_u8) DECL(test_i16) DECL(test_u16)
+DECL(test_i32) DECL(test_u32) DECL(test_i64) DECL(test_cmp)
+
+int main(void) {
+    uint64_t values[] = {0xa5a5a5a500000000ULL, 0xa5a5a5a50000007fULL,
+        0xa5a5a5a500000080ULL, 0xa5a5a5a500007fffULL, 0xa5a5a5a500008000ULL,
+        0xa5a5a5a57fffffffULL, 0xa5a5a5a580000000ULL, 0xa5a5a5a5ffffffffULL};
+    for(unsigned i=0; i<sizeof(values)/sizeof(values[0]); i++) {
+        c_bits=values[i];
+        int64_t actual[]={test_i8(),test_u8(),test_i16(),test_u16(),test_i32(),test_u32(),test_i64(),test_cmp()};
+        int64_t expected[]={(int8_t)c_bits,(uint8_t)c_bits,(int16_t)c_bits,(uint16_t)c_bits,
+                            (int32_t)c_bits,(uint32_t)c_bits,(int64_t)c_bits,(int32_t)c_bits==-1};
+        for(unsigned j=0; j<8; j++)
+            if(actual[j]!=expected[j]) {
+                printf("case %u type %u: %lld != %lld\n",i,j,(long long)actual[j],(long long)expected[j]);
+                return 1;
+            }
+    }
+    return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/fib.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/fib.c
new file mode 100644
index 00000000..263d2f13
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/fib.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+
+__attribute__ ((CALL_CONV))
+extern int fib(int x);
+
+int main() {
+  printf("[");
+  for (int i = 0; i < 10; i++) {
+    printf("%d", fib(i));
+    if (i < 9) printf(", ");
+  }
+  printf("]");
+  return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/funptr.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/funptr.c
new file mode 100644
index 00000000..2abe6e74
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/funptr.c
@@ -0,0 +1,15 @@
+#include <assert.h>
+#include <stdint.h>
+
+typedef int64_t (*Function)(void);
+typedef int64_t (*Printer)(void *, void *);
+extern Function factory(int64_t);
+extern Printer printer(void);
+
+int main(void) {
+    assert(factory(1)() == 42);
+    assert(factory(0)() == 43);
+    struct { uint32_t length; char data[2]; } text = {2, {'o','k'}};
+    printer()(0, &text); // Unused class receiver, then the byte array.
+    return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/jig.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/jig.smp
new file mode 100644
index 00000000..29987d8e
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/jig.smp
@@ -0,0 +1,16 @@
+// -*- mode: java;  -*-
+val _fib = {int n ->
+    int temp=0;
+    int f1=1;
+    int f2=1;
+    int i=n;
+    while( i>1 ){
+        temp = f1+f2;
+        f1=f2;
+        f2=temp;
+        i=i-1;
+    }
+    return f2;
+};
+
+_fib(10);
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/loop2.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/loop2.c
new file mode 100644
index 00000000..934f2d89
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/loop2.c
@@ -0,0 +1,7 @@
+
+__attribute__ ((CALL_CONV))
+extern int loop2();
+
+int main() {
+  return loop2();
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/newtonFloat.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/newtonFloat.c
new file mode 100644
index 00000000..7e7e796d
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/newtonFloat.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+
+extern double test_sqrt(double);
+
+int main( int argc, char** argv ) {
+  for( int i=0; i<10; i++ ) {
+    double d = test_sqrt((double)i), expect = sqrt((double)i);
+    double delta = fabs(d-expect);
+    printf("%d  %f   (%g)\n",i,d,delta);
+    if( delta > 1e-15 )
+      return 1;
+  }
+  return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp
new file mode 100644
index 00000000..be2dffec
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/newtonFloat.smp
@@ -0,0 +1,12 @@
+// -*- mode: java;  -*-
+// Newtons approximation to the square root
+val test_sqrt = { flt x ->
+    flt epsilon = 1e-15;
+    flt guess = x;
+    while( 1 ) {
+        flt next = (x/guess + guess)/2;
+        if( guess-epsilon <= next & next <= guess+epsilon ) return guess;
+        //if( guess==next ) return guess;
+        guess = next;
+    }
+};
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp
new file mode 100644
index 00000000..20a05445
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/no_stack_arg_count.smp
@@ -0,0 +1,6 @@
+// -*- mode: java;  -*-
+val addAll = { int i0, flt f1, int i2, flt f3, int i4, flt f5, int i6, flt f7, int x8, flt f9, int i10, flt f11, int i12, flt f13, int i14, flt f15 ->
+    return
+    i0 + f1+ i2+ f3+ i4+ f5+ i6+ f7+ x8 +f9 +
+    i10+f11+i12+f13+i14+f15;
+};
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person.c
new file mode 100644
index 00000000..df95e1ca
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct Person {
+    int age;
+} Person;
+
+typedef struct PersonArray {
+    unsigned int length;
+    int pad;
+    Person* data[];
+} PersonArray;
+
+__attribute__ ((CALL_CONV))
+extern void fcn(PersonArray* people, int index);
+
+int main() {
+    Person base[5] = {{25},{1},{18},{45},{60}};
+    unsigned char buf[8+8*5];
+    PersonArray* people_array = (PersonArray*)buf;
+    people_array->length=5;
+    for (int i=0; i<people_array->length; i++) people_array->data[i] = &base[i];
+
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+
+    printf("%d\n", people_array->data[1]->age); // expected: 6
+
+    return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person21.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person21.c
new file mode 100644
index 00000000..df95e1ca
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person21.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct Person {
+    int age;
+} Person;
+
+typedef struct PersonArray {
+    unsigned int length;
+    int pad;
+    Person* data[];
+} PersonArray;
+
+__attribute__ ((CALL_CONV))
+extern void fcn(PersonArray* people, int index);
+
+int main() {
+    Person base[5] = {{25},{1},{18},{45},{60}};
+    unsigned char buf[8+8*5];
+    PersonArray* people_array = (PersonArray*)buf;
+    people_array->length=5;
+    for (int i=0; i<people_array->length; i++) people_array->data[i] = &base[i];
+
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+    fcn(people_array, 1);
+
+    printf("%d\n", people_array->data[1]->age); // expected: 6
+
+    return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person21.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person21.smp
new file mode 100644
index 00000000..b5e6ee90
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/person21.smp
@@ -0,0 +1,9 @@
+// -*-java-*-
+struct Person {
+    int age;
+};
+
+val fcn = { !Person?[] ps, int x ->
+    if( ps[x] )
+        ps[x].age++;
+};
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/sieve.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/sieve.c
new file mode 100644
index 00000000..cac4cfa3
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/sieve.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+typedef struct AryInt {
+  unsigned int len;
+  unsigned int data[];
+} AryInt;
+
+__attribute__ ((CALL_CONV))
+extern AryInt *sieve(int N);
+
+int main() {
+  AryInt* ps = sieve(100);
+  printf("%d[",ps->len);
+  for( int i=0; i<ps->len; i++ )
+    printf("%d, ",ps->data[i]);
+  printf("]");
+  return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/sort.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/sort.c
new file mode 100644
index 00000000..ad76cc7f
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/sort.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+// Test wrapper to call `sort.smp`
+
+typedef struct AryInt {
+    unsigned int len;
+    long long data[];
+} AryInt;
+
+__attribute__ ((CALL_CONV))
+extern AryInt* merge_sort(AryInt*);
+
+
+long long primes[] = { 25, 97, 89, 83, 79, 73, 71, 67, 61, 59, 53, 47, 43, 41, 37, 31, 29, 23, 19, 17, 13, 11, 7, 5, 3, 2 };
+
+int main() {
+  AryInt *as = (AryInt*)primes;
+
+  merge_sort(as);
+
+  printf("%d[",as->len);
+  for( int i=0; i<as->len; i++ )
+    printf("%d, ",as->data[i]);
+  printf("]");
+
+  return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c
new file mode 100644
index 00000000..d44d5387
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_10x.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+__attribute__ ((CALL_CONV))
+extern int stack10(int x);
+
+int main() {
+int result = stack10(0);
+
+printf("%d", result);
+return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c
new file mode 100644
index 00000000..d71979d1
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_11x.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+__attribute__ ((CALL_CONV))
+extern int stack11(int x);
+
+int main() {
+int result = stack11(1);
+
+printf("%d", result);
+return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_12x.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_12x.c
new file mode 100644
index 00000000..a4e425cb
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_12x.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+__attribute__ ((CALL_CONV))
+extern int stack12(int x);
+
+int main() {
+int result = stack12(0);
+
+printf("%d", result);
+return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_13x.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_13x.c
new file mode 100644
index 00000000..a3a51d0e
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_13x.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+__attribute__ ((CALL_CONV))
+extern int stack13(int x);
+
+int main() {
+int result = stack13(0);
+
+printf("%d", result);
+return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c
new file mode 100644
index 00000000..4f93ba24
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stacked_r_9x.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+__attribute__ ((CALL_CONV))
+extern int stack9(int x);
+
+int main() {
+int result = stack9(0);
+
+printf("%d", result);
+return 0;
+}
\ No newline at end of file
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash.c b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash.c
new file mode 100644
index 00000000..2c6d0fa9
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+typedef struct ArrayU8 {
+  unsigned int length;
+  unsigned char data[];
+} ArrayU8;
+typedef struct String {
+  ArrayU8 * cs;
+  long long _hashCode;
+} String;
+
+
+__attribute__ ((CALL_CONV))
+extern bool equals(String*st1, String*st2);
+
+int main() {
+  String test1 = {.cs=(ArrayU8*)"\x04\x00\x00\x00test"};
+  String test2 = {.cs=(ArrayU8*)"\x05\x00\x00\x00test1"};
+
+  if( equals(&test1, &test2) ) {
+    printf("Expected test1 and test2 unequal");
+    return 1;
+  }
+  if( !equals(&test2, &test2) ) {
+    printf("Expected test2 and test2 equal");
+    return 1;
+  }
+  return 0;
+}
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash.smp
new file mode 100644
index 00000000..7344fcdd
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash.smp
@@ -0,0 +1,30 @@
+// -*- mode: java;  -*-
+struct String {
+    u8[] cs;
+    int _hashCode;
+};
+
+// Compare two Strings
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+// Return the String hashCode (cached, and never 0)
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    for( int i=0; i< self.cs#; i++ )
+        hash = hash*31 + self.cs[i];
+    if( !hash ) hash = 123456789;
+    return hash;
+};
diff --git a/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash21.smp b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash21.smp
new file mode 100644
index 00000000..257f79f9
--- /dev/null
+++ b/chapter-sccp/src/test/java/com/seaofnodes/simple/progs/stringHash21.smp
@@ -0,0 +1,31 @@
+// -*- mode: java;  -*-
+struct String {
+    u8[] cs;
+    int _hashCode;
+};
+
+// Compare two Strings
+val equals = { !String !self, !String s ->
+    if( self == s ) return true;
+    if( self.cs# != s.cs# ) return false;
+    for( int i=0; i< self.cs#; i++ )
+        if( self.cs[i] != s.cs[i] )
+            return false;
+    return true;
+};
+
+// Return the String hashCode (cached, and never 0)
+val hashCode = { !String self ->
+    self._hashCode
+    ?  self._hashCode
+    : (self._hashCode = _hashCodeString(self));
+};
+
+val _hashCodeString = { !String self ->
+    int hash=0;
+    if( self.cs )
+        for( int i=0; i< self.cs#; i++ )
+            hash = hash*31 + self.cs[i];
+    if( !hash ) hash = 123456789;
+    return hash;
+};