Chapter renumber, and split ch 17

Renumber chapters 10a, 10b, 11, 12, 13, 14 -> 10, 11, 13, 12, [11,14].
Split ch 17 into a 17a and 17b; shuffle around im/mutable syntax to be consistent, and present it more slowly.
THe new immutable syntax is pushed through all later chapters

100 files changed, 15131 insertions, 0 deletions

diff --git a/chapter17b/Makefile b/chapter17b/Makefile
new file mode 100644
index 00000000..3f1e53ff
--- /dev/null
+++ b/chapter17b/Makefile
@@ -0,0 +1,106 @@
+SHELL := /bin/bash
+# Shared packaging target; included after chapter source variables below.
+.DELETE_ON_ERROR:
+
+# for printing variable values
+# usage: make print-VARIABLE
+#        > VARIABLE = value_of_variable
+print-%  : ; @echo $* = $($*)
+
+# literal space
+space := $() $()
+
+# Decide OS-specific questions
+# jar-file seperator
+ifeq ($(OS),Windows_NT)
+	SEP = ;
+else
+	SEP = :
+endif
+# Find a reasonable ctags.
+CTAGS = $(shell which ctags)
+# Hack for MacOS: /usr/bin/ctags is unfriendly, so look for ctags from brew
+ifeq ($(UNAME),Darwin)
+	CTAGS = $(shell brew list ctags 2> /dev/null | grep bin/ctags)
+endif
+
+# Fun Args to javac.  Mostly limit to java8 source definitions, and fairly
+# aggressive lint warnings.
+JAVAC_ARGS = -g
+
+# Source code
+SIMPLE := com/seaofnodes/simple
+SRC := src/main/java
+TST := src/test/java
+CLZDIR:= build/classes
+main_javas   := $(wildcard $(SRC)/$(SIMPLE)/*java $(SRC)/$(SIMPLE)/*/*java)
+test_javas   := $(wildcard $(TST)/$(SIMPLE)/*java $(TST)/$(SIMPLE)/*/*java)
+main_classes := $(patsubst $(SRC)/%java,$(CLZDIR)/main/%class,$(main_javas))
+include $(firstword $(wildcard ../graph/graph.mk graph/graph.mk))
+include $(firstword $(wildcard ../print/print.mk print/print.mk))
+test_classes := $(patsubst $(TST)/%java,$(CLZDIR)/test/%class,$(test_javas))
+test_cp      := $(patsubst $(TST)/$(SIMPLE)/%.java,com.seaofnodes.simple.%,$(wildcard $(TST)/$(SIMPLE)/*Test.java))
+classes = $(main_classes) $(test_classes)
+# All the libraries
+libs = $(wildcard lib/*jar)
+jars = $(subst $(space),$(SEP),$(libs))
+
+
+default_targets := $(main_classes) $(test_classes)
+# Optionally add ctags to the default target if a reasonable one was found.
+ifneq ($(CTAGS),)
+default_targets += tags
+endif
+
+default: $(default_targets)
+
+# Compile just the out-of-date files
+$(main_classes): build/classes/main/%class: $(SRC)/%java $(graph_javas) $(print_javas)
+	@echo "compiling " $@ " because " $?
+	@[ -d $(CLZDIR)/main ] || mkdir -p $(CLZDIR)/main
+	@javac $(JAVAC_ARGS) -cp "$(CLZDIR)/main$(SEP)$(jars)" -sourcepath $(SRC) -d $(CLZDIR)/main $(main_javas)
+
+$(test_classes): $(CLZDIR)/test/%class: $(TST)/%java $(main_classes)
+	@echo "compiling " $@ " because " $?
+	@[ -d $(CLZDIR)/test ] || mkdir -p $(CLZDIR)/test
+	@javac $(JAVAC_ARGS) -cp "$(CLZDIR)/test$(SEP)$(CLZDIR)/main$(SEP)$(jars)" -sourcepath $(TST) -d $(CLZDIR)/test $(test_javas)
+
+# Base launch line for JVM tests
+JVM=nice java -ea -cp "build/classes/main${SEP}${jars}${SEP}$(CLZDIR)/test"
+
+tests:	$(default_targets)
+	@echo "testing " $(test_cp)
+	@$(JVM) org.junit.runner.JUnitCore $(test_cp) com.seaofnodes.simple.FuzzerWrap
+
+fuzzer: $(default_targets)
+	@echo "fuzzing " $(test_cp)
+	@$(JVM) org.junit.runner.JUnitCore com.seaofnodes.simple.FuzzerWrap
+
+
+.PHONY: clean
+clean:
+	rm -rf build
+	rm -f TAGS
+	(find . -name "*~" -exec rm {} \; 2>/dev/null; exit 0)
+
+# Download libs from maven
+lib:	lib/junit-4.12.jar  lib/hamcrest-core-1.3.jar
+
+# Jars
+lib/junit-4.12.jar:
+	@[ -d lib ] || mkdir -p lib
+	@(cd lib; wget https://repo1.maven.org/maven2/junit/junit/4.12/junit-4.12.jar)
+
+lib/hamcrest-core-1.3.jar:
+	@[ -d lib ] || mkdir -p lib
+	@(cd lib; wget https://repo1.maven.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar)
+
+# Build emacs tags (part of a tasty emacs ide experience)
+tags:	$(main_javas) $(test_javas)
+	@rm -f TAGS
+	@$(CTAGS) -e --recurse=yes --extra=+q --fields=+fksaiS $(SRC) $(TST)
+
+include $(firstword $(wildcard ../build-support/chapter-release.mk build-support/chapter-release.mk))
+
+.PHONY: build
+build: $(main_classes)
diff --git a/chapter17b/README.md b/chapter17b/README.md
new file mode 100644
index 00000000..5bdfb9e4
--- /dev/null
+++ b/chapter17b/README.md
@@ -0,0 +1,112 @@
+# Chapter 17b: Syntax Sugar
+
+[Previous: Chapter 17a](../chapter17a/README.md) |
+[Next: Chapter 18](../chapter18/README.md)
+
+
+## Table of Contents
+
+1. [Pre/Post-increment](#prepost-increment)
+2. [Operator assignment](#operator-assignment)
+3. [var/val](#var--val)
+4. [Trinary](#trinary)
+5. [For Loops](#for-loops)
+6. [Memory effects](#memory-effects)
+
+Chapter 17a established the permissions checked by assignments. This chapter
+adds shorter ways to write assignments and control flow without changing those
+permissions. Chapter 18 then introduces functions and calls.
+
+## Pre/Post-increment
+
+Allow `arg++` and `arg--` with the usual meanings; the value is updated and the
+expression is the pre-update value.  Greedy match is used so `arg---arg` parses
+as `(arg--)-arg`.
+
+Also allows `s.fld++` and `ary[idx]++`, and their `--` variants.
+
+Allow pre-increment for identifiers only, for now: `--pc`.
+
+
+## Operator assignment
+
+Along the same lines as post-increment, we now allow `op=` assignment
+on local variables with semantics similar to other languages. The supported
+operators are `+=`, `-=`, `*=`, `/=`, `&=`, `|=`, `^=`, `<<=`, `>>=`, and `>>>=`.
+Bitwise and shift assignments require integer operands; `>>=` preserves the sign
+while `>>>=` shifts in zeros. The assignment evaluates its right-hand side once,
+stores the result narrowed to the variable's type, and yields that stored value.
+Assignments associate right-to-left, as in `x |= y <<= 2`.
+
+
+
+## var & val
+
+`var` and `val` declare variables and infer their types; `var` infers a
+reassignable binding while `val` infers a fixed binding.  Both preserve access
+permissions from the initializing expression.  Neither makes a writable object
+read-only.  The two independent permissions come from [Chapter
+17a](../chapter17a/README.md).
+
+```cpp
+struct Point { int x; };
+val p = new Point; // Fixed binding to a writable new object
+p.x = 3;           // Allowed
+// p = new Point;  // Error: fixed binding
+Point view = p;    // Explicit read-only view
+var q = view;      // Reassignable binding, still read-only access
+// q.x = 4;        // Error: cannot restore write permission by inference
+```
+
+The initializer is required for type inference.  Primitives infer their broad
+numeric type (`int` or `flt`); references retain their access permissions.  A
+reassignable inferred reference allows null so it can later hold the empty
+value.  Explicit types retain their declared width and nullability.  Function
+parameters still require explicit types.
+
+## Trinary
+
+Allow `pred ? e_true : e_false`.  Also allow `pred ? e_true`, where the false result
+is the zero type version of the true result.
+
+
+## For Loops
+
+Allow C/C++ style `for` loops:
+
+`for( init; test; next ) body`
+
+Example:
+
+```cpp
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return sum;
+```
+
+Any of `init`, `test` and `next` can be empty.  `init` allows for declaration
+of a new variable, with scope limited to the `for` expression.
+
+```cpp
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return i; // ERROR: Undefined name 'i'
+```
+
+A broken `find` call:
+```cpp
+for( int i=0; i<ary#; i++ )
+  if( ary[i]==e )
+    break;
+do_stuff(i); // ERROR: undefined name 'i'
+```
+
+An example `find` call:
+```cpp
+for( int i=0; i<ary#; i++ )
+  if( ary[i]==e )
+    return i;
+return -1;
+```
diff --git a/chapter17b/chapter17b.iml b/chapter17b/chapter17b.iml
new file mode 100644
index 00000000..3075ff71
--- /dev/null
+++ b/chapter17b/chapter17b.iml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/../build/idea/production/chapter17b" />
+    <output-test url="file://$MODULE_DIR$/../build/idea/test/chapter17b" />
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="graph" />
+    <orderEntry type="module" module-name="print" />
+    <orderEntry type="module-library" scope="TEST">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/junit-4.12.jar!/" />
+          <root url="jar://$MODULE_DIR$/lib/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>
diff --git a/chapter17b/docs/17-grammar.md b/chapter17b/docs/17-grammar.md
new file mode 100644
index 00000000..9a70f323
--- /dev/null
+++ b/chapter17b/docs/17-grammar.md
@@ -0,0 +1,22 @@
+# Chapter 17b grammar additions
+
+Start with [Chapter 17a's declaration syntax](../../chapter17a/docs/17-grammar.md).
+This chapter adds inference, assignment shortcuts, conditional expressions, and
+`for` loops. Access and binding permissions keep the same meaning.
+
+```text
+inferredDeclaration = ("var" | "val") ("!" | "~")? identifier "=" assignment
+assignment          = expression (assignmentOperator assignment)?
+assignmentOperator  = "=" | "+=" | "-=" | "*=" | "/=" | "&=" | "|=" | "^="
+                    | "<<=" | ">>=" | ">>>="
+expression          = bitwise ("?" assignment (":" assignment)?)?
+prefixUpdate        = ("++" | "--") identifier
+postfixUpdate       = lvalue ("++" | "--")
+forStatement        = "for" "(" declarationOrExpression? ";" assignment? ";"
+                      assignment? ")" statement
+```
+
+Declarations can contain several comma-separated names. `var` permits
+reassignment and `val` fixes the binding; both retain the initializer's reference
+permissions. Postfix updates also support fields and array elements. Prefix
+updates currently support local names. See the README for evaluation order.
diff --git a/chapter17b/docs/Makefile b/chapter17b/docs/Makefile
new file mode 100644
index 00000000..12659b8f
--- /dev/null
+++ b/chapter17b/docs/Makefile
@@ -0,0 +1,12 @@
+GV := $(wildcard *.gv)
+SVG := $(patsubst %.gv,%.svg,$(GV))
+
+.PHONY: all
+all: $(SVG)
+
+%.svg: %.gv
+	dot -Tsvg $< > $@
+
+.PHONY: clean
+clean:
+	@rm -f $(SVG)
diff --git a/chapter17b/pom.xml b/chapter17b/pom.xml
new file mode 100644
index 00000000..1eef8185
--- /dev/null
+++ b/chapter17b/pom.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.seaofnodes</groupId>
+        <artifactId>simple</artifactId>
+        <version>1.0</version>
+    </parent>
+    <artifactId>chapter17b</artifactId>
+    <packaging>jar</packaging>
+    <name>Chapter 17b</name>
+    <properties>
+        <simple.graph.directory>${project.basedir}/../graph</simple.graph.directory>
+        <simple.print.directory>${project.basedir}/../print</simple.print.directory>
+    </properties>
+</project>
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/Ary.java b/chapter17b/src/main/java/com/seaofnodes/simple/Ary.java
new file mode 100644
index 00000000..8654d41e
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/Ary.java
@@ -0,0 +1,217 @@
+package com.seaofnodes.simple;
+
+import java.lang.StringBuilder;
+import java.lang.reflect.Array;
+import java.util.*;
+
+// ArrayList with saner syntax
+public class Ary<E> extends AbstractList<E> implements List<E> {
+    public E[] _es;
+    public int _len;
+
+    public Ary(E[] es) { this(es,es.length); }
+    public Ary(E[] es, int len) { if( es.length==0 ) es=Arrays.copyOf(es,1); _es=es; _len=len; }
+    @SuppressWarnings("unchecked")
+    public Ary(Class<E> clazz) { this((E[]) Array.newInstance(clazz, 1),0); }
+
+    /** @return list is empty */
+    public boolean isEmpty() { return _len==0; }
+    /** @return active list length */
+    public int len() { return _len; }
+    public int size() { return len(); }
+
+    /** @param i element index
+     *  @return element being returned; throws if OOB
+     *  @exception AIOOBE if !(0 <= i < _len)
+     */
+    public E get( int i ) { return at(i); }
+    public E at( int i ) {
+        range_check(i);
+        return _es[i];
+    }
+
+    /** @return last element */
+    public E last( ) { return at(_len-1); }
+
+    /** Add element in amortized constant time
+     *  @param e Element to add at end of list
+     **/
+    public E push( E e ) {
+        if( _len >= _es.length ) _es = Arrays.copyOf(_es,Math.max(1,_es.length<<1));
+        return (_es[_len++] = e);
+    }
+    /** @return remove and return last element */
+    public E pop( ) {
+        range_check(0);
+        return _es[--_len];
+    }
+    @Override public E removeLast() { return pop(); }
+
+
+    /** Add element in amortized constant time
+     *  @param e Element to add at end of list
+     *  @return true */
+    public boolean add( E e ) {
+        if( _len >= _es.length ) _es = Arrays.copyOf(_es,Math.max(1,_es.length<<1));
+        _es[_len++] = e;
+        return true;
+    }
+
+    ///** Slow, linear-time, element insert.  Preserves order.
+    // *  @param i index to insert at, between 0 and _len inclusive.
+    // *  @param e Element to insert
+    // */
+    //public void insert( int i, E e ) {
+    //    if( i < 0 || i>_len )
+    //        throw new ArrayIndexOutOfBoundsException(""+i+" >= "+_len);
+    //    if( _len >= _es.length ) _es = Arrays.copyOf(_es,Math.max(1,_es.length<<1));
+    //    System.arraycopy(_es,i,_es,i+1,(_len++)-i);
+    //    _es[i] = e;
+    //}
+
+    /** Fast, constant-time, element removal.  Does not preserve order
+     *  @param i element to be removed
+     *  @return element removed */
+    public E del( int i ) {
+        range_check(i);
+        E tmp = _es[i];
+        _es[i]=_es[--_len];
+        return tmp;
+    }
+
+    ///** Element removal, using '=='.  Does not preserve order.
+    // *  @param e element to be removed
+    // *  @return element removed */
+    //public E del( E e ) {
+    //    for( int i=0; i<_len; i++ ) {
+    //        E tmp = _es[i];
+    //        if( tmp==e ) {
+    //            _es[i]=_es[--_len];
+    //            return tmp;
+    //        }
+    //    }
+    //    return null;
+    //}
+
+    /** Slow, linear-time, element removal.  Preserves order.
+     *  @param i element to be removed
+     *  @return element removed */
+    @Override public E remove( int i ) {
+        range_check(i);
+        E e = _es[i];
+        System.arraycopy(_es,i+1,_es,i,(--_len)-i);
+        return e;
+    }
+
+    /** Remove all elements */
+    public void clear( ) { _len=0; }
+
+    /** Set existing element
+     *  @param i element to set
+     *  @param e value to set
+     *  @return old value
+     *  @exception AIOOBE if !(0 <= i < _len)
+     */
+    public E set( int i, E e ) {
+        range_check(i);
+        E old = _es[i];
+        _es[i] = e;
+        return old;
+    }
+
+    public Ary<E> setLen( int len ) {
+        if( len > _len )
+            while( len>= _es.length ) _es = Arrays.copyOf(_es,_es.length<<1);
+        _len = len;
+        while( _es.length > (len<<1) ) // Shrink if hugely too large
+            _es = Arrays.copyOf(_es,_es.length>>1);
+        Arrays.fill(_es,len,_es.length,null);
+        return this;
+    }
+
+    /** @param c Collection to be added */
+    public boolean addAll( Collection<? extends E> c ) {
+        if( c==null ) return false;
+        for( E e : c ) add(e);
+        return true;
+    }
+    public Ary<E> addAll( Iterable<? extends E> it ) { for( E e : it ) add(e); return this; }
+
+    /** @param es Array to be added */
+    public <F extends E> Ary<E> addAll( F[] es ) {
+        if( es==null || es.length==0 ) return this;
+        while( _len+es.length > _es.length ) _es = Arrays.copyOf(_es,_es.length<<1);
+        System.arraycopy(es,0,_es,_len,es.length);
+        _len += es.length;
+        return this;
+    }
+
+    /** @param c Collection to be added */
+    public Ary<E> addAll( Ary<? extends E> c ) {
+        if( c==null || c._len==0 ) return this;
+        while( _len+c._len > _es.length ) _es = Arrays.copyOf(_es,_es.length<<1);
+        System.arraycopy(c._es,0,_es,_len,c._len);
+        _len += c._len;
+        return this;
+    }
+
+  /** @return compact array version */
+  public E[] asAry() { return Arrays.copyOf(_es,_len); }
+
+  /** Sorts in-place
+   *  @param c Comparator to sort by */
+  public void sort_update(Comparator<? super E> c ) { Arrays.sort(_es, 0, _len, c);  }
+
+    /** Find the first matching element using ==, or -1 if none.  Note that
+     *  most del calls shuffle the list, so the first element might be random.
+     *  @param e Element to find
+     *  @return index of first matching element, or -1 if none */
+    public int find( E e ) {
+        for( int i=0; i<_len; i++ )  if( _es[i]==e )  return i;
+        return -1;
+    }
+
+
+    /** @return an iterator */
+    @Override public Iterator<E> iterator() { return new Iter(); }
+    private class Iter implements Iterator<E> {
+        int _i=0;
+        @Override public boolean hasNext() { return _i<_len; }
+        @Override public E next() { return _es[_i++]; }
+    }
+
+    @Override public String toString() {
+        StringBuilder sb = new StringBuilder().append('{');
+        for( int i=0; i<_len; i++ ) {
+            if( i>0 ) sb.append(',');
+            if( _es[i] != null ) sb.append(_es[i].toString());
+        }
+        return sb.append('}').toString();
+    }
+
+    private void range_check( int i ) {
+        if( i < 0 || i>=_len )
+            throw new ArrayIndexOutOfBoundsException(""+i+" >= "+_len);
+    }
+
+    // Note that the hashCode() and equals() are not invariant to changes in the
+    // underlying array.  If the hashCode() is used (e.g., inserting into a
+    // HashMap) and the then the array changes, the hashCode() will change also.
+    @Override public boolean equals( Object o ) {
+        if( this==o ) return true;
+        if( !(o instanceof Ary ary) ) return false;
+        if( _len != ary._len ) return false;
+        if( _es == ary._es ) return true;
+        for( int i=0; i<_len; i++ )
+            if( !(_es[i]==null ? (ary._es[i] == null) : _es[i].equals(ary._es[i])) )
+                return false;
+        return true;
+    }
+    @Override public int hashCode( ) {
+        int sum=_len;
+        for( int i=0; i<_len; i++ )
+            sum += _es[i]==null ? 0 : _es[i].hashCode();
+        return sum;
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/GlobalCodeMotion.java b/chapter17b/src/main/java/com/seaofnodes/simple/GlobalCodeMotion.java
new file mode 100644
index 00000000..eba99128
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/GlobalCodeMotion.java
@@ -0,0 +1,238 @@
+ package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.IterPeeps.WorkList;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+import java.util.*;
+
+public abstract class GlobalCodeMotion {
+
+    // Arrange that the existing isCFG() Nodes form a valid CFG.  The
+    // Node.use(0) is always a block tail (either IfNode or head of the
+    // following block).  There are no unreachable infinite loops.
+    public static void buildCFG( StopNode stop ) {
+        schedEarly();
+        Parser.SCHEDULED = true;
+        schedLate( stop);
+    }
+
+
+    // ------------------------------------------------------------------------
+    // Visit all nodes in CFG Reverse Post-Order, essentially defs before uses
+    // (except at loops).  Since defs are visited first - and hoisted as early
+    // as possible, when we come to a use we place it just after its deepest
+    // input.
+    private static void schedEarly() {
+        ArrayList<CFGNode> rpo = new ArrayList<>();
+        BitSet visit = new BitSet();
+        _rpo_cfg(Parser.START, visit, rpo);
+        // Reverse Post-Order on CFG
+        for( int j=rpo.size()-1; j>=0; j-- ) {
+            CFGNode cfg = rpo.get(j);
+            cfg.loopDepth();
+            for( Node n : cfg._inputs )
+                _schedEarly(n,visit);
+            // In dead infinite loops, entire code blocks may be unreachable
+            // from below.  Reach down from the CFG to their Phis so their
+            // inputs are scheduled too.
+            if( cfg instanceof RegionNode )
+                for( Node phi : cfg._outputs )
+                    if( phi instanceof PhiNode )
+                        _schedEarly(phi,visit);
+        }
+    }
+
+    // Post-Order of CFG
+    private static void _rpo_cfg(Node n, BitSet visit, ArrayList<CFGNode> rpo) {
+        if( !(n instanceof CFGNode cfg) || visit.get(cfg._nid) )
+            return;             // Been there, done that
+        visit.set(cfg._nid);
+        for( Node use : cfg._outputs )
+            _rpo_cfg(use,visit,rpo);
+        rpo.add(cfg);
+    }
+
+    private static void _schedEarly(Node n, BitSet visit) {
+        if( n==null || visit.get(n._nid) ) return; // Been there, done that
+        assert !(n instanceof CFGNode);
+        visit.set(n._nid);
+        // Schedule inputs first, except Phis: following their backedges would
+        // enter a data cycle before its control has been scheduled.
+        for( Node def : n._inputs )
+            if( def!=null && !(def instanceof PhiNode) )
+                _schedEarly(def,visit);
+        // An existing edge 0 already supplies control (or a Phi/Proj binding).
+        if( n.in(0)==null ) {
+            // Schedule at deepest input
+            CFGNode early = Parser.START; // Maximally early, lowest idepth
+            for( int i=1; i<n.nIns(); i++ )
+                if( n.in(i)!=null && n.in(i).cfg0().idepth() > early.idepth() )
+                    early = n.in(i).cfg0(); // Latest/deepest input
+            n.setDef(0,early);              // First place this can go
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    private static void schedLate( StopNode stop) {
+        CFGNode[] late = new CFGNode[Node.UID()];
+        Node[] ns = new Node[Node.UID()];
+        // Record Load NIDs at all their CFG block choices, then check against
+        // Store block choices to force a Load above an anti-dependent Store.
+        int[] anti = new int[Node.UID()];
+        // Breadth-first scheduling
+        breadth(stop,ns,late,anti);
+
+        // Copy the best placement choice into the control slot
+        for( int i=0; i<late.length; i++ )
+            if( ns[i] != null && !(ns[i] instanceof ProjNode) )
+                ns[i].setDef(0,late[i]);
+    }
+
+    private static void breadth(Node stop, Node[] ns, CFGNode[] late, int[] anti) {
+        // Things on the worklist have some (but perhaps not all) uses done.
+        WorkList<Node> work = new WorkList<>();
+        work.push(stop);
+        Node n;
+        outer:
+        while( (n = work.pop()) != null ) {
+            assert late[n._nid]==null; // No double visit
+            // These I know the late schedule of, and need to set early for loops
+            if( n instanceof CFGNode cfg ) late[n._nid] = cfg.blockHead() ? cfg : cfg.cfg(0);
+            else if( n instanceof PhiNode phi ) late[n._nid] = phi.region();
+            else if( n instanceof ProjNode && n.in(0) instanceof CFGNode cfg ) late[n._nid] = cfg;
+            else {
+
+                // All uses done?
+                for( Node use : n._outputs )
+                    if( use!=null && late[use._nid]==null )
+                        continue outer; // Nope, await all uses done
+
+                // Loads need their memory inputs' uses also done
+                if( n instanceof LoadNode ld )
+                    for( Node memuse : ld.antiDeps() )
+                        if( late[memuse._nid]==null )
+                            continue outer;
+
+                // All uses done, schedule
+                _doSchedLate(n,ns,late,anti);
+            }
+
+            // A use just finished; reconsider its inputs and waiting loads,
+            // even when the shared memory input was already scheduled.
+            for( Node def : n._inputs ) {
+                if( def==null ) continue;
+                if( late[def._nid]==null ) work.push(def);
+                wakeLoads(def,late,work,new BitSet());
+            }
+            if( n instanceof LoopNode loop )
+                for( Node phi : loop._outputs )
+                    if( phi instanceof PhiNode && late[phi._nid]==null )
+                        work.push(phi);
+        }
+    }
+
+    private static void _doSchedLate(Node n, Node[] ns, CFGNode[] late, int[] anti) {
+        // Walk uses, gathering the LCA (Least Common Ancestor) of uses
+        CFGNode early = n.in(0) instanceof CFGNode cfg ? cfg : n.in(0).cfg0();
+        assert early != null;
+        CFGNode lca = null;
+        for( Node use : n._outputs )
+            if( use != null )
+              lca = use_block(n,use, late).domLCA(lca,null);
+
+        // Loads may need anti-dependencies, raising their LCA
+        if( n instanceof LoadNode load )
+            lca = find_anti_dep(lca,load,early,late,anti);
+
+        // Walk up from the LCA to the early, looking for best place.  This is
+        // the lowest execution frequency, approximated by least loop depth and
+        // deepest control flow.
+        CFGNode best = lca;
+        lca = lca.idom();       // Already found best for starting LCA
+        for( ; lca != early.idom(); lca = lca.idom() )
+            if( better(lca,best) )
+                best = lca;
+        assert !(best instanceof IfNode);
+        ns  [n._nid] = n;
+        late[n._nid] = best;
+    }
+
+    // Block of use.  Normally from late[] schedule, except for Phis, which go
+    // to the matching Region input.
+    private static CFGNode use_block(Node n, Node use, CFGNode[] late) {
+        if( !(use instanceof PhiNode phi) )
+            return late[use._nid];
+        CFGNode found=null;
+        for( int i=1; i<phi.nIns(); i++ )
+            if( phi.in(i)==n )
+                found = phi.region().cfg(i).domLCA(found,null); // Can be more than one matching input.
+        assert found!=null;
+        return found;
+    }
+
+
+    // Least loop depth first, then largest idepth
+    private static boolean better( CFGNode lca, CFGNode best ) {
+        return lca.loopDepth() < best.loopDepth() ||
+            lca instanceof NeverNode ||
+            lca.idepth() > best.idepth() ||
+            best instanceof IfNode;
+    }
+
+    // An allocation may consume a load's memory through a partial aggregate.
+    private static void wakeLoads(Node def, CFGNode[] late, WorkList<Node> work, BitSet visit) {
+        if( visit.get(def._nid) ) return;
+        visit.set(def._nid);
+        for( Node out : def._outputs )
+            if( out instanceof LoadNode ld && late[ld._nid]==null ) work.push(ld);
+        if( def instanceof MemMergeNode )
+            for( int i=1; i<def.nIns(); i++ )
+                if( def.in(i)!=null ) wakeLoads(def.in(i),late,work,visit);
+    }
+
+    private static CFGNode find_anti_dep(CFGNode lca, LoadNode load, CFGNode early, CFGNode[] late, int[] anti) {
+        // We could skip final-field loads here.
+        // Walk LCA->early, flagging Load's block location choices
+        for( CFGNode cfg=lca; early!=null && cfg!=early.idom(); cfg = cfg.idom() )
+            anti[cfg._nid] = load._nid;
+        // Walk load->mem uses, looking for Stores causing an anti-dep
+        for( Node mem : load.antiDeps() ) {
+            switch( mem ) {
+            case StoreNode st:
+                assert late[st._nid]!=null;
+                lca = anti_dep(load,late[st._nid],st.cfg0(),lca,st,anti);
+                break;
+            case NewNode st:
+                assert late[st._nid]!=null;
+                lca = anti_dep(load,late[st._nid],st.cfg0(),lca,st,anti);
+                break;
+            case PhiNode phi:
+                // Repeat anti-dep for matching Phi inputs.
+                // No anti-dep edges but may raise the LCA.
+                for( int i=1; i<phi.nIns(); i++ )
+                    if( phi.in(i)==load.mem() )
+                        lca = anti_dep(load,phi.region().cfg(i),load.mem().cfg0(),lca,null,anti);
+                break;
+            default: throw Utils.TODO();
+            }
+        }
+        return lca;
+    }
+
+    //
+    private static CFGNode anti_dep( LoadNode load, CFGNode stblk, CFGNode defblk, CFGNode lca, Node st, int[] anti ) {
+        // Preserve the full store range for the earlier evaluator scheduler.
+        // It places nodes independently of GCM and may hoist this store.
+        for( ; stblk != defblk.idom(); stblk = stblk.idom() ) {
+            // Store and Load overlap, need anti-dependence
+            if( anti[stblk._nid]==load._nid ) {
+                lca = stblk.domLCA(lca,null); // Raise Loads LCA
+                if( lca == stblk && st != null && st._inputs.find(load) == -1 ) // And if something moved,
+                    st.addDef(load);   // Add anti-dep as well
+                return lca;            // Cap this stores' anti-dep to here
+            }
+        }
+        return lca;
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/IRPrinter.java b/chapter17b/src/main/java/com/seaofnodes/simple/IRPrinter.java
new file mode 100644
index 00000000..7e93e9da
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/IRPrinter.java
@@ -0,0 +1,33 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.print.IRAdapter;
+import com.seaofnodes.simple.node.*;
+
+/** This chapter's read-only IR facts and the familiar debugger entry points. */
+public final class IRPrinter extends IRAdapter<Node> {
+    private static final com.seaofnodes.print.IRPrinter<Node> PRINT =
+        new com.seaofnodes.print.IRPrinter<>(new IRPrinter());
+    @Override public String type(Node n) { return n._type==null ? "" : n._type.str(); }
+    @Override public String inputMark(Node n, Node def) { return n instanceof MemMergeNode && def instanceof MemMergeNode ? "^" : " "; }
+    @Override public Kind kind(Node n) {
+        if( n instanceof StartNode ) return Kind.START;
+        if( n instanceof StopNode ) return Kind.STOP;
+        if( n instanceof LoopNode ) return Kind.LOOP;
+        if( n instanceof RegionNode ) return Kind.REGION;
+        if( n instanceof PhiNode ) return Kind.PHI;
+        if( n instanceof ReturnNode ) return Kind.RETURN;
+        if( n instanceof ConstantNode ) return Kind.CONSTANT;
+        if( n instanceof CProjNode ) return Kind.CPROJ;
+        if( n instanceof ProjNode ) return n instanceof CFGNode ? Kind.CPROJ : Kind.PROJ;
+        if( n instanceof CFGNode ) return Kind.CTRL;
+        if( n instanceof MultiNode ) return Kind.MULTI;
+        return Kind.DATA;
+    }
+    @Override public int index(Node n) {
+        if( n instanceof ProjNode p ) return p._idx;
+        if( n instanceof CProjNode p ) return p._idx;
+        return n._nid;
+    }
+
+    public static String prettyPrint(Node n, int depth) { return PRINT.prettyPrint(n,depth); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/IterPeeps.java b/chapter17b/src/main/java/com/seaofnodes/simple/IterPeeps.java
new file mode 100644
index 00000000..5a80698a
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/IterPeeps.java
@@ -0,0 +1,211 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.*;
+
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Random;
+
+/**
+ * The IterPeeps runs after parsing. It iterates the peepholes to a fixed point
+ * so that no more peepholes apply.  This should be linear because peepholes rarely
+ * (never?)  increase code size.  The graph should monotonically reduce in some
+ * dimension, which is usually size.  It might also reduce in e.g. number of
+ * MulNodes or Load/Store nodes, swapping out more "expensive" Nodes for cheaper
+ * ones.
+ * <br>
+ * The theoretical overall worklist is mindless just grabbing the next thing and
+ * doing it.  If the graph changes, put the neighbors on the worklist.
+ * <br>
+ * Lather, Rinse, Repeat until the worklist runs dry.
+ * <p>
+ * The main issues we have to deal with:
+ *
+ * <ul>
+ * <li>Nodes have uses; replacing some set of Nodes with another requires more graph
+ *   reworking.  Not rocket science, but it can be fiddly.  Its helpful to have a
+ *   small set of graph munging utilities, and the strong invariant that the graph
+ *   is stable and correct between peepholes.  In our case `Node.subsume` does
+ *   most of the munging, building on our prior stable Node utilities.</li>
+ *
+ * <li>Changing a Node also changes the graph "neighborhood".  The neighbors need to
+ *   be checked to see if THEY can also peephole, and so on.  After any peephole
+ *   or graph update we put a Nodes uses and defs on the worklist.</li>
+ *
+ * <li>Our strong invariant is that for all Nodes, either they are on the worklist
+ *   OR no peephole applies.  This invariant is easy to check, although expensive.
+ *   Basically the normal "iterate peepholes to a fixed point" is linear, and this
+ *   check is linear at each peephole step... so quadratic overall.  Its a useful
+ *   assert, but one we can disable once the overall algorithm is stable - and
+ *   then turn it back on again when some new set of peepholes is misbehaving.
+ *   The code for this is turned on in `IterPeeps.iterate` as `assert
+ *   progressOnList(stop);`</li>
+ * </ul>
+ */
+public abstract class IterPeeps {
+
+    private static final WorkList<Node> WORK = new WorkList<>();
+
+    public static <N extends Node> N add( N n ) {
+        return (N)WORK.push(n);
+    }
+
+    public static void addAll( Ary<Node> ary ) {
+        WORK.addAll(ary);
+    }
+
+    /**
+     * Iterate peepholes to a fixed point
+     */
+    public static StopNode iterate(StopNode stop) {
+        assert progressOnList(stop);
+        int cnt=0;
+
+        Node n;
+        while( (n=WORK.pop()) != null ) {
+            if( n.isDead() )  continue;
+            cnt++;              // Useful for debugging, searching which peephole broke things
+            var obs = Parser.PARSER == null ? null : Parser.PARSER._obs;
+            if( obs != null ) obs.before(n);
+            Node x = n.peepholeOpt();
+            if( x != null ) {
+                if( x.isDead() ) {
+                    if( obs != null ) obs.after(n, x, true);
+                    continue;
+                }
+                // peepholeOpt can return brand-new nodes, needing an initial type set
+                if( x._type==null ) x.setType(x.compute());
+                // Changes require neighbors onto the worklist
+                if( x != n || !(x instanceof ConstantNode) ) {
+                    // All outputs of n (changing node) not x (prior existing node).
+                    for( Node z : n._outputs ) WORK.push(z);
+                    // Everybody gets a free "go again" in case they didn't get
+                    // made in their final form.
+                    WORK.push(x);
+                    // If the result is not self, revisit all inputs (because
+                    // there's a new user), and replace in the graph.
+                    if( x != n ) {
+                        for( Node z : n. _inputs ) WORK.push(z);
+                        n.subsume(x);
+                    }
+                }
+                // If there are distant neighbors, move to worklist
+                n.moveDepsToWorklist();
+                assert progressOnList(stop); // Very expensive assert
+            }
+            if( n.isUnused() && !(n instanceof StopNode) )
+                n.kill();       // Just plain dead
+            if( obs != null ) obs.after(n, x, true);
+        }
+
+        return stop;
+    }
+
+    // Visit ALL nodes and confirm the invariant:
+    //   Either you are on the WORK worklist OR running `iter()` makes no progress.
+
+    // This invariant ensures that no progress is missed, i.e., when the
+    // worklist is empty we have indeed done all that can be done.  To help
+    // with debugging, the {@code assert} is broken out in a place where it is easy to
+    // stop if a change is found.
+
+    // Also, the normal usage of `iter()` may attempt peepholes with distance
+    // neighbors and these should fail, but will then try to add dependencies
+    // {@link #Node.addDep} which is a side effect in an assert.  The {@link
+    // #midAssert} is used to stop this side effect.
+    private static boolean MID_ASSERT;
+    public static boolean midAssert() { return MID_ASSERT; }
+    private static boolean progressOnList(Node stop) {
+        MID_ASSERT = true;
+        int old_cnt = Node.ITER_CNT, old_nop = Node.ITER_NOP_CNT;
+        Node changed = stop.walk( n -> {
+                Node m = n;
+                if( n.compute().isa(n._type) && (!n.iskeep() || n._nid<=5) ) { // Types must be forwards, even if on worklist
+                    if( WORK.on(n) ) return null;
+                    m = n.peepholeOpt();
+                    if( m==null ) return null;
+                }
+                System.err.println("BREAK HERE FOR BUG");
+                return m;
+            });
+        Node.ITER_CNT = old_cnt;  Node.ITER_NOP_CNT = old_nop;
+        MID_ASSERT = false;
+        return changed==null;
+    }
+
+    public static void reset() {
+        WORK.clear();
+    }
+
+    /**
+     * Classic WorkList, with a fast add/remove, dup removal, random pull.
+     * The Node's nid is used to check membership in the worklist.
+     */
+    public static class WorkList<E extends Node> {
+
+        private Node[] _es;
+        private int _len;
+        private final BitSet _on;   // Bit set if Node._nid is on WorkList
+        private final Random _R;    // For randomizing pull from the WorkList
+        private final long _seed;
+
+        /* Useful stat - how many nodes are processed in the post parse iterative opt */
+        private long _totalWork = 0;
+
+        WorkList() { this(123); }
+        WorkList(long seed) {
+            _es = new Node[1];
+            _len=0;
+            _on = new BitSet();
+            _seed = seed;
+            _R = new Random();
+            _R.setSeed(_seed);
+        }
+
+        /**
+         * Pushes a Node on the WorkList, ensuring no duplicates
+         * If Node is null it will not be added.
+         */
+        public E push( E x ) {
+            if( x==null ) return null;
+            int idx = x._nid;
+            if( !_on.get(idx) ) {
+                _on.set(idx);
+                if( _len==_es.length )
+                    _es = Arrays.copyOf(_es,_len<<1);
+                _es[_len++] = x;
+                _totalWork++;
+            }
+            return x;
+        }
+
+        public void addAll( Ary<E> ary ) {
+            for( E n : ary )
+                push(n);
+        }
+
+        /**
+         * True if Node is on the WorkList
+         */
+        boolean on( E x ) { return _on.get(x._nid); }
+
+        /**
+         * Removes a random Node from the WorkList; null if WorkList is empty
+         */
+        E pop() {
+            if( _len == 0 ) return null;
+            int idx = _R.nextInt(_len);
+            E x = (E)_es[idx];
+            _es[idx] = _es[--_len]; // Compress array
+            _on.clear(x._nid);
+            return x;
+        }
+
+        public void clear() {
+            _len = 0;
+            _on.clear();
+            _R.setSeed(_seed);
+            _totalWork = 0;
+        }
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/Parser.java b/chapter17b/src/main/java/com/seaofnodes/simple/Parser.java
new file mode 100644
index 00000000..776aa91f
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/Parser.java
@@ -0,0 +1,1450 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.graph.GraphObserver;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+
+import java.util.*;
+
+/**
+ * The Parser converts a Simple source program to the Sea of Nodes intermediate
+ * representation directly in one pass.  There is no intermediate Abstract
+ * Syntax Tree structure.
+ * <p>
+ * This is a simple recursive descent parser. All lexical analysis is done here as well.
+ */
+public class Parser {
+
+    // Current compilation context; the observer belongs to the parser.
+    public static Parser PARSER;
+    public GraphObserver<Node> _obs;
+    public int pos() { return _lexer._position; }
+
+
+    /**
+     * A Global Static, unique to each compilation.  This is a public, so we
+     * can make constants everywhere without having to thread the StartNode
+     * through the entire parser and optimizer.
+     * <p>
+     * To make the compiler multithreaded, this field will have to move into a TLS.
+     */
+    public static StartNode START;
+
+    public static ConstantNode ZERO; // Very common node, cached here
+    public static XCtrlNode XCTRL;   // Very common node, cached here
+
+    // Next available memory alias number
+    static int ALIAS;
+
+    public StopNode STOP;
+
+    // Debugger Printing.
+    public static boolean SCHEDULED; // True if debug printer can use schedule info
+
+    // The Lexer.  Thin wrapper over a byte[] buffer with a cursor.
+    private final Lexer _lexer;
+
+    /**
+     * Current ScopeNode - ScopeNodes change as we parse code, but at any point of time
+     * there is one current ScopeNode. The reason the current ScopeNode can change is to do with how
+     * we handle branching. See {@link #parseIf()}.
+     * <p>
+     * Each ScopeNode contains a stack of lexical scopes, each scope is a symbol table that binds
+     * variable names to Nodes.  The top of this stack represents current scope.
+     * <p>
+     * We keep a list of all ScopeNodes so that we can show them in graphs.
+     * @see #parseIf()
+     * @see #_xScopes
+     */
+    public ScopeNode _scope;
+
+    /**
+     * List of keywords disallowed as identifiers
+     */
+    private static final HashSet<String> KEYWORDS = new HashSet<>(){{
+            add("bool");
+            add("break");
+            add("byte");
+            add("continue");
+            add("else");
+            add("f32");
+            add("f64");
+            add("false");
+            add("flt");
+            add("i16");
+            add("i32");
+            add("i64");
+            add("i8");
+            add("if");
+            add("int");
+            add("new");
+            add("null");
+            add("return");
+            add("struct");
+            add("true");
+            add("u1");
+            add("u16");
+            add("u32");
+            add("u8");
+            add("while");
+        }};
+
+
+    /**
+     * We clone ScopeNodes when control flows branch; it is useful to have
+     * a list of all active ScopeNodes for purposes of visualization of the SoN graph
+     */
+    public final Stack<ScopeNode> _xScopes = new Stack<>();
+
+    ScopeNode _continueScope;
+    ScopeNode _breakScope;      // Merge all the while-breaks here
+
+    // Mapping from a type name to a Type.  The string name matches
+    // `type.str()` call.  No TypeMemPtrs are in here, because Simple does not
+    // have C-style '*ptr' references.
+    public static HashMap<String, Type> TYPES;
+
+    // Mapping from a type name to the constructor for a Type.
+    public final HashMap<String, StructNode> INITS;
+
+
+    public Parser(String source, TypeInteger arg) {
+        PARSER = this;
+        Node.reset();
+        IterPeeps.reset();
+        SCHEDULED = false;
+        _lexer = new Lexer(source);
+        _scope = new ScopeNode();
+        _continueScope = _breakScope = null;
+        START = new StartNode(arg);
+        STOP = new StopNode(source);
+        ZERO = con(0).keep();
+        XCTRL= new XCtrlNode().peephole().keep();
+        ALIAS = 2; // alias 0 for the control, 1 for memory
+        TYPES = defaultTypes();
+        INITS = new HashMap<>();
+    }
+
+    public Parser(String source) {
+        this(source, TypeInteger.BOT);
+    }
+
+    @Override
+    public String toString() { return _lexer.toString(); }
+
+    public static HashMap<String, Type> defaultTypes() {
+        return new HashMap<>() {{
+            put("bool",TypeInteger.U1 );
+            put("byte",TypeInteger.U8 );
+            put("f32" ,TypeFloat  .B32);
+            put("f64" ,TypeFloat  .BOT);
+            put("flt" ,TypeFloat  .BOT);
+            put("i16" ,TypeInteger.I16);
+            put("i32" ,TypeInteger.I32);
+            put("i64" ,TypeInteger.BOT);
+            put("i8"  ,TypeInteger.I8 );
+            put("int" ,TypeInteger.BOT);
+            put("u1"  ,TypeInteger.U1 );
+            put("u16" ,TypeInteger.U16);
+            put("u32" ,TypeInteger.U32);
+            put("u8"  ,TypeInteger.U8 );
+            put("val" ,Type.TOP);    // Marker type, indicates type inference
+            put("var" ,Type.BOTTOM); // Marker type, indicates type inference
+        }};
+    }
+
+    // Debugging utility to find a Node by index
+    public static Node find(int nid) { return START.find(nid); }
+
+    private Node ctrl() { return _scope.ctrl(); }
+    private <N extends Node> N ctrl(N n) { return _scope.ctrl(n); }
+
+    public StopNode parse() {
+        _xScopes.push(_scope);
+        // Enter a new scope for the initial control and arguments
+        _scope.push();
+        _scope.define(ScopeNode.CTRL, Type.CONTROL   , false, new CProjNode(START, 0, ScopeNode.CTRL).peephole());
+        _scope.define(ScopeNode.MEM0, TypeMem.BOT    , false, new  ProjNode(START, 1, ScopeNode.MEM0).peephole());
+        _scope.define(ScopeNode.ARG0, TypeInteger.BOT, false, new  ProjNode(START, 2, ScopeNode.ARG0).peephole());
+
+        // Parse whole program
+        parseBlock(false);
+
+        if( ctrl()._type==Type.CONTROL )
+            STOP.addReturn(new ReturnNode(ctrl(), ZERO, _scope).peephole());
+        _scope.kill();
+        _xScopes.pop();
+        for( StructNode init : INITS.values() )
+            init.unkeep().kill();
+        INITS.clear();
+        if (!_lexer.isEOF()) throw error("Syntax error, unexpected " + _lexer.getAnyNextToken());
+        STOP.peephole();
+        return STOP;
+    }
+
+    /**
+     * Parses a block
+     *
+     * <pre>
+     *     '{' statements '}'
+     * </pre>
+     * Does not parse the opening or closing '{}'
+     * @return a {@link Node} or {@code null}
+     */
+    private Node parseBlock(boolean inCon) {
+        // Enter a new scope
+        _scope.push(inCon);
+        while (!peek('}') && !_lexer.isEOF())
+            parseStatement();
+        // Exit scope
+        _scope.pop();
+        return null;
+    }
+
+    /**
+     * Parses a statement
+     *
+     * <pre>
+     *     returnStatement | declStatement | blockStatement | ifStatement | expressionStatement
+     * </pre>
+     * @return a {@link Node} or {@code null}
+     */
+    private Node parseStatement() {
+        if( false ) return null;
+        else if (matchx("return")  ) return parseReturn();
+        else if (match ("{")       ) return require(parseBlock(false),"}");
+        else if (matchx("if")      ) return parseIf();
+        else if (matchx("while")   ) return parseWhile();
+        else if (matchx("for")     ) return parseFor();
+        else if (matchx("break")   ) return parseBreak();
+        else if (matchx("continue")) return parseContinue();
+        else if (matchx("struct")  ) return parseStruct();
+        else if (matchx(";")       ) return null; // Empty statement
+        // Declaration or normal assignment/expression
+        else return parseDeclarationStatement();
+    }
+
+    /**
+     * Parses a while statement
+     *
+     * <pre>
+     *     while ( expression ) statement
+     * </pre>
+     * @return a {@link Node}, never {@code null}
+     */
+    private Node parseWhile() {
+        require("(");
+        return parseLooping(false);
+    }
+
+
+    /**
+     * Parses a for statement
+     *
+     * <pre>
+     *     for( var x=init; test; incr ) body
+     * </pre>
+     * @return a {@link Node}, never {@code null}
+     */
+    private Node parseFor() {
+        // {   var x=init,y=init,...;
+        //     while( pred ) {
+        //         body;
+        //         next;
+        //     }
+        // }
+        require("(");
+        _scope.push();          // Scope for the index variables
+        if( !match(";") )       // Can be empty init "for(;test;next) body"
+            parseDeclarationStatement(); // Non-empty init
+        Node rez = parseLooping(true);
+        _scope.pop();           // Exit index variable scope
+        return rez;
+    }
+
+    // Shared by `for` and `while`
+    private Node parseLooping( boolean doFor ) {
+
+        var savedContinueScope = _continueScope;
+        var savedBreakScope    = _breakScope;
+
+        // Loop region has two control inputs, the first is the entry
+        // point, and second is back edge that is set after loop is parsed
+        // (see end_loop() call below).  Note that the absence of back edge is
+        // used as an indicator to switch off peepholes of the region and
+        // associated phis; see {@code inProgress()}.
+
+        ctrl(new LoopNode(ctrl()).peephole()); // Note we set back edge to null here
+
+        // At loop head, we clone the current Scope (this includes all
+        // names in every nesting level within the Scope).
+        // We create phis eagerly for all the names we find, see dup().
+
+        // Save the current scope as the loop head
+        ScopeNode head = _scope.keep();
+        // Clone the head Scope to create a new Scope for the body.
+        // Create phis eagerly as part of cloning
+        _xScopes.push(_scope = _scope.dup(true)); // The true argument triggers creating phis
+
+        // Parse predicate
+        var pred = peek(';') ? con(1) : parseAsgn();
+        require( doFor ? ";" : ")" );
+
+        // IfNode takes current control and predicate
+        Node ifNode = new IfNode(ctrl(), pred.keep()).peephole();
+        // Setup projection nodes
+        Node ifT = new CProjNode(ifNode.  keep(), 0, "True" ).peephole().keep();
+        Node ifF = new CProjNode(ifNode.unkeep(), 1, "False").peephole();
+
+        // for( ;;next ) body
+        int nextPos = -1, nextEnd = -1;
+        if( doFor ) {
+            // Skip the next expression and parse it later
+            nextPos = pos();
+            skipAsgn();
+            nextEnd = pos();
+            require(")");
+        }
+
+        // Clone the body Scope to create the break/exit Scope which accounts for any
+        // side effects in the predicate.  The break/exit Scope will be the final
+        // scope after the loop, and its control input is the False branch of
+        // the loop predicate.  Note that body Scope is still our current scope.
+        ctrl(ifF);
+        _xScopes.push(_breakScope = _scope.dup());
+        _breakScope.addGuards(ifF,pred,true); // Up-cast predicate
+
+        // No continues yet
+        _continueScope = null;
+
+        // Parse the true side, which corresponds to loop body
+        // Our current scope is the body Scope
+        ctrl(ifT.unkeep());     // set ctrl token to ifTrue projection
+        _scope.addGuards(ifT,pred.unkeep(),false); // Up-cast predicate
+        parseStatement();       // Parse loop body
+        _scope.removeGuards(ifT);
+
+        // Merge the loop bottom into other continue statements
+        if (_continueScope != null) {
+            _continueScope = jumpTo(_continueScope);
+            _scope.kill();
+            _scope = _continueScope;
+        }
+
+        // Now append the next code onto the body code
+        if( doFor ) {
+            int old = pos(nextPos);
+            if( !peek(')') )
+              parseAsgn();
+            if( pos() != nextEnd )
+                throw errorSyntax( "Unexpected code after expression" );
+            pos(old);
+        }
+
+        // The true branch loops back, so whatever is current _scope.ctrl gets
+        // added to head loop as input.  endLoop() updates the head scope, and
+        // goes through all the phis that were created earlier.  For each phi,
+        // it sets the second input to the corresponding input from the back
+        // edge.  If the phi is redundant, it is replaced by its sole input.
+        var exit = _breakScope;
+        head.endLoop(_scope, exit);
+        head.unkeep().kill();
+
+        _xScopes.pop();       // Cleanup
+        _xScopes.pop();       // Cleanup
+
+        _continueScope = savedContinueScope;
+        _breakScope = savedBreakScope;
+
+        // At exit the false control is the current control, and
+        // the scope is the exit scope after the exit test.
+        _xScopes.pop();
+        _xScopes.push(exit);
+        _scope = exit;
+        return _scope;
+    }
+
+    private ScopeNode jumpTo(ScopeNode toScope) {
+        ScopeNode cur = _scope.dup();
+        ctrl(XCTRL); // Kill current scope
+        // Prune nested lexical scopes that have depth > than the loop head
+        // We use _breakScope as a proxy for the loop head scope to obtain the depth
+        while( cur._lexSize.size() > _breakScope._lexSize.size() )
+            cur.pop();
+        // If this is a continue then first time the target is null
+        // So we just use the pruned current scope as the base for the
+        // "continue"
+        if( toScope == null )
+            return cur;
+        // toScope is either the break scope, or a scope that was created here
+        assert toScope._lexSize.size() <= _breakScope._lexSize.size();
+        toScope.ctrl(toScope.mergeScopes(cur).peephole());
+        return toScope;
+    }
+
+    private void checkLoopActive() { if (_breakScope == null) throw Parser.error("No active loop for a break or continue"); }
+
+    private Node parseContinue() { checkLoopActive(); return (_continueScope = require(jumpTo( _continueScope ),";"));  }
+    private Node parseBreak   () {
+        checkLoopActive();
+        // At the time of the break, and loop-exit conditions are only valid if
+        // they are ALSO valid at the break.  It is the intersection of
+        // conditions here, not the union.
+        _breakScope.removeGuards(_breakScope.ctrl());
+        _breakScope = require(jumpTo(_breakScope ),";");
+        _breakScope.addGuards(_breakScope.ctrl(), null, false);
+        return _breakScope;
+    }
+
+    // Look for an unbalanced `)`, skipping balanced
+    private Type skipAsgn() {
+        int paren=0;
+        while( true )
+            // Next X char handles skipping complex comments
+            switch( _lexer.nextXChar() ) {
+            case Character.MAX_VALUE:
+                throw Utils.TODO();
+            case ')':
+                if( --paren<0 )
+                    return posT(pos()-1); // Leave the `)` behind
+                break;
+            case '(': paren ++; break;
+            default: break;
+            }
+    }
+
+
+    /**
+     * Parses a statement
+     *
+     * <pre>
+     *     if ( expression ) statement [else statement]
+     * </pre>
+     * @return a {@link Node}, never {@code null}
+     */
+    private Node parseIf() {
+        // Parse predicate
+        require("(");
+        var pred = require(parseAsgn(), ")");
+        return parseTrinary(pred,true,"else");
+    }
+
+    // Parse a conditional expression, merging results.
+    private Node parseTrinary( Node pred, boolean stmt, String fside ) {
+        pred.keep();
+
+        // IfNode takes current control and predicate
+        Node ifNode = new IfNode(ctrl(), pred).peephole();
+        // Setup projection nodes
+        Node ifT = new CProjNode(ifNode.  keep(), 0, "True" ).peephole().keep();
+        Node ifF = new CProjNode(ifNode.unkeep(), 1, "False").peephole().keep();
+        // In if true branch, the ifT proj node becomes the ctrl
+        // But first clone the scope and set it as current
+        int ndefs = _scope.nIns();
+        ScopeNode fScope = _scope.dup(); // Duplicate current scope
+        fScope.ctrl(ifF);       // The pending arm already starts at False
+        _xScopes.push(fScope); // For graph visualization we need all scopes
+
+        // Parse the true side
+        ctrl(ifT.unkeep());     // set ctrl token to ifTrue projection
+        _scope.addGuards(ifT,pred,false); // Up-cast predicate
+        Node lhs = stmt ? parseStatement() : parseAsgn().keep(); // Parse true-side
+        _scope.removeGuards(ifT);
+
+        ScopeNode tScope = _scope;
+
+        // Parse the false side
+        _scope = fScope;        // Restore scope, then parse else block if any
+        ifF.unkeep();           // fScope already owns the false control
+        // Up-cast predicate, even if not else clause, because predicate can
+        // remain true if the true clause exits: `if( !ptr ) return 0; return ptr.fld;`
+        _scope.addGuards(ifF,pred,true);
+        boolean doRHS = match(fside);
+        Node rhs = doRHS
+            ? (stmt ? parseStatement() : parseAsgn())
+            : (stmt ? null             : con(lhs._type.makeZero()));
+        _scope.removeGuards(ifF);
+        if( doRHS )
+            fScope = _scope;
+        pred.unkeep();
+
+        // Check for `if(pred) int x=17;`
+        if( tScope.nIns() != ndefs || fScope.nIns() != ndefs )
+            throw error("Cannot define a new name on one arm of an if");
+
+        // Check the trinary widening int/flt
+        if( !stmt ) {
+            rhs = widenInt( rhs, lhs._type ).keep();
+            lhs = widenInt( lhs.unkeep(), rhs._type ).keep();
+            rhs.unkeep();
+        }
+
+        // Merge results
+        _scope = tScope;
+        _xScopes.pop();       // Discard pushed from graph display
+
+        RegionNode r = ctrl(tScope.mergeScopes(fScope));
+        Node ret = stmt ? r : peep(new PhiNode("",lhs._type.meet(rhs._type),r,lhs.unkeep(),rhs));
+        r.peephole();
+        return ret;
+    }
+
+    /**
+     * Parses a return statement; "return" already parsed.
+     * The $ctrl edge is killed.
+     *
+     * <pre>
+     *     'return' expr ;
+     * </pre>
+     * @return an expression {@link Node}, never {@code null}
+     */
+    private Node parseReturn() {
+        var expr = require(parseAsgn(), ";");
+        Node ret = STOP.addReturn(new ReturnNode(ctrl(), expr, _scope).peephole());
+        ctrl(XCTRL);            // Kill control
+        return ret;
+    }
+
+
+
+    /** Parse: [name '='] expr
+     */
+    private Node parseAsgn() {
+        int old = pos();
+        String name = _lexer.matchId();
+        // Just a plain expression, no assignment.
+        // Distinguish `var==expr` from `var=expr`
+        if( name==null || KEYWORDS.contains(name) || !matchOpx('=','=') )
+            {  pos(old);  return parseExpression();  }
+
+        // Parse assignment expression
+        Node expr = parseAsgn();
+
+        // Final variable to update
+        ScopeNode.Var def = _scope.lookup(name);
+        if( def==null )
+            throw error("Undefined name '" + name + "'");
+
+        // TOP fields are for late-initialized fields; these have never
+        // been written to, and this must be the final write.  Other writes
+        // outside the constructor need to check the final bit.
+        if( _scope.in(def._idx)._type!=Type.TOP && def._final && !_scope.canInit(def) )
+            throw error("Cannot reassign final '"+name+"'");
+
+        // Lift expression, based on type
+        Node lift = liftExpr(expr, def.type());
+        // Update
+        _scope.update(name,lift);
+        // Return un-lifted expr
+        return expr;
+    }
+
+    // Apply declared access permissions; widen floats and narrow integers.
+    // Early error if types do not match variable.
+    private Node liftExpr( Node expr, Type t ) {
+        assert !(expr._type instanceof TypeMemPtr tmp) || !tmp.isFRef();
+        // Read-only access is deep; a fixed binding alone does not remove access.
+        if( t instanceof TypeMemPtr tmp && tmp.isFinal() ) {
+            expr = peep(new ReadOnlyNode(expr));
+        }
+        // Auto-widen int to float
+        expr = widenInt( expr, t );
+        // Auto-narrow wide ints to narrow ints
+        expr = zsMask(expr,t);
+        // Type is sane
+        if( !expr._type.isa(t) || !expr._type.accessISA(t) )
+            throw error("Type " + expr._type.str() + " is not of declared type " + t.str());
+        return expr;
+    }
+
+    private Node widenInt( Node expr, Type t ) {
+        return expr._type instanceof TypeInteger && t instanceof TypeFloat
+            ? peep(new ToFloatNode(expr)) : expr;
+    }
+
+    /**
+     * Parse declaration or expression statement
+     * declStmt = type var['=' exprAsgn][, var['=' exprAsgn]]* ';' | exprAsgn ';'
+     * <p>
+     * exprAsgn = var '=' exprAsgn | expr
+     */
+    private Node parseDeclarationStatement() {
+        Type t = type();
+        if( t == null )
+            return require(parseAsgn(),";");
+
+        // now parse var['=' asgnexpr] in a loop
+        Node n = parseDeclaration(t);
+        while( match(",") )
+            n = parseDeclaration(t);
+        return require(n,";");
+    }
+
+    // The binding modifier sits immediately before the name. It never
+    // changes permissions on the referenced object.
+    private boolean bindingFinal(Type t) {
+        if( match("!") ) return false;
+        if( match("~") ) return true;
+        return t==Type.TOP || t instanceof TypeMemPtr;
+    }
+
+    /** Parse final: [!|~]var['=' asgn]
+     */
+    private Node parseDeclaration(Type t) {
+        assert t!=null;
+        // Has var/val instead of a user-declared type
+        boolean inferType = t==Type.TOP || t==Type.BOTTOM;
+        boolean xfinal = bindingFinal(t);
+        String name = requireId();
+
+        // Optional initializing expression follows
+        Node expr;
+        if( match("=") ) {
+            expr = parseAsgn();
+            // var/val, then type comes from expression
+            if( inferType )
+                t = expr._type instanceof TypeMemPtr ptr ? ptr.makeFrom(true) : expr._type.glb();
+
+        } else {
+            if( inferType && !_scope.inCon() )
+                throw errorSyntax("=expression");
+            expr = con(xfinal && !(t instanceof TypeMemPtr) ? Type.TOP : t.makeInit());
+        }
+
+        // Lift expression, based on type
+        Node lift = liftExpr(expr, t);
+
+        // Define a new name,
+        if( !_scope.define(name,t,xfinal,lift) )
+            throw error("Redefining name '" + name + "'");
+        return null;
+    }
+
+
+
+    /**
+     * Parse a struct declaration, and return the following statement.
+     * Only allowed in top level scope.
+     * Structs cannot be redefined.
+     *
+     * @return The statement following the struct
+     */
+    private Node parseStruct() {
+        if (_xScopes.size() > 1) throw errorSyntax("struct declarations can only appear in top level scope");
+        String typeName = requireId();
+        Type t = TYPES.get(typeName);
+        if( t!=null && !(t instanceof TypeMemPtr tmp && tmp.isFRef() ) )
+            throw errorSyntax("struct '" + typeName + "' cannot be redefined");
+
+        // A Block scope parse, and inspect the scope afterward for fields.
+        _scope.push(true);
+        _xScopes.push(_scope);
+        require("{");
+        while (!peek('}') && !_lexer.isEOF())
+            parseStatement();
+
+        // Grab the declarations and build fields and a Struct
+        int lexlen = _scope._lexSize.last();
+        int varlen = _scope._vars._len;
+        StructNode s = new StructNode();
+        Field[] fs = new Field[varlen-lexlen];
+        for( int i=lexlen; i<varlen; i++ ) {
+            s.addDef(_scope.in(i));
+            ScopeNode.Var v = _scope._vars.at(i);
+            fs[i-lexlen] = Field.make(v._name,v.type(),ALIAS++,v._final);
+        }
+        TypeStruct ts = s._ts = TypeStruct.make(typeName, fs);
+        TYPES.put(typeName, TypeMemPtr.make(ts));
+        INITS.put(typeName,s.peephole().keep());
+        // Done with struct/block scope
+        require("}");
+        require(";");
+        _xScopes.pop();
+        _scope.pop();
+        return null;
+    }
+
+
+    // Parse and return a type or null.  Valid types always are followed by an
+    // 'id' which the caller must parse.  This lets us distinguish forward ref
+    // types (which ARE valid here) from local vars in an (optional) forward
+    // ref type position.
+
+    // t = int|i8|i16|i32|i64|u8|u16|u32|u64|byte|bool | flt|f32|f64 | val | var | struct[?]
+    private Type type() {
+        int old1 = pos();
+        boolean writable = match("!");
+        boolean readonly = !writable && match("~");
+        String tname = _lexer.matchId();
+        if( tname==null ) return posT(old1);
+        // Convert the type name to a type.
+        Type t0 = TYPES.get(tname);
+        // No new types as keywords
+        if( t0 == null && KEYWORDS.contains(tname) )
+            return posT(old1);
+        Type t1 = t0 == null ? TypeMemPtr.make(TypeStruct.makeFRef(tname)) : t0; // Null: assume a forward ref type
+        // A qualifier before the name applies to the struct reference, not
+        // to an enclosing array. Arrays have their own [] / [~] qualifier.
+        if( t1 instanceof TypeMemPtr tmp ) {
+            if( readonly || !writable ) t1 = tmp.makeRO();
+        } else if( writable || readonly )
+            return posT(old1);
+
+        // Nest arrays and '?' as needed
+        Type t2 = t1;
+        while( true ) {
+            assert !(t2 instanceof TypeStruct);
+            if( match("?") ) {
+                if( !(t2 instanceof TypeMemPtr tmp) )
+                    throw error("Type "+t0+" cannot be null");
+                if( tmp._nil ) throw error("Type "+t2+" already allows null");
+                t2 = tmp.makeFrom(true);
+            } else if( match("[~]") ) {
+                TypeMemPtr ary = typeAry(t2);
+                t2 = ary.makeFrom(ary._obj.makeRO()).makeRO();
+            } else if( match("[]") ) {
+                t2 = typeAry(t2);
+            } else
+                break;
+        }
+
+        // Check no forward ref
+        if( t0 != null ) return t2;
+        // Check valid forward ref, after parsing all the type extra bits.
+        // Cannot check earlier, because cannot find required 'id' until after "[]?" syntax
+        int old2 = pos();
+        if( !match("!") ) match("~");
+        String id = _lexer.matchId();
+        pos(old2);              // Reset lexer to reparse
+        if( id==null || _scope.lookup(id)!=null )
+            return posT(old1);  // Reset lexer to reparse
+        // Yes a forward ref, so declare it
+        TYPES.put(tname,((TypeMemPtr)t1).withAccess(false));
+        return t2;
+    }
+
+    // Make an array type of t
+    private TypeMemPtr typeAry( Type t ) {
+        if( t instanceof TypeMemPtr tmp && !tmp._nil )
+            throw error("Arrays of reference types must always be nullable");
+        String tname = "["+t.str()+"]";
+        Type ta = TYPES.get(tname);
+        if( ta != null ) {
+            TypeStruct ary = ((TypeMemPtr)ta)._obj;
+            // Keep the original shallow struct reference.  Resolving a recursive
+            // struct must not expand its array element type on each lookup.
+            if( t instanceof TypeMemPtr ptr && (ptr._obj._fields==null || !ptr._obj.isAry()) &&
+                ary._fields[1]._type instanceof TypeMemPtr old )
+                t = old.withAccess(ptr._ro);
+            return TypeMemPtr.make(TypeStruct.makeAry(TypeInteger.BOT,ary._fields[0]._alias,t,ary._fields[1]._alias));
+        }
+        // Need make an array type.
+        TypeStruct ts = TypeStruct.makeAry(TypeInteger.BOT,ALIAS++,t,ALIAS++);
+        assert ts.str().equals(tname);
+        TypeMemPtr tary = TypeMemPtr.make(ts);
+        TYPES.put(tname,tary);
+        return tary;
+    }
+
+    /**
+     * Parse an expression of the form:
+     *
+     * <pre>
+     *     expr : bitwise [? expr [: expr]]
+     * </pre>
+     * @return an expression {@link Node}, never {@code null}
+     */
+    private Node parseExpression() {
+        Node expr = parseBitwise();
+        return match("?") ? parseTrinary(expr,false,":") : expr;
+    }
+
+    /**
+     * Parse an bitwise expression
+     *
+     * <pre>
+     *     bitwise : compareExpr (('&' | '|' | '^') compareExpr)*
+     * </pre>
+     * @return a bitwise expression {@link Node}, never {@code null}
+     */
+    private Node parseBitwise() {
+        Node lhs = parseComparison();
+        while( true ) {
+            if( false ) ;
+            else if( match("&") ) lhs = new AndNode(lhs,null);
+            else if( match("|") ) lhs = new  OrNode(lhs,null);
+            else if( match("^") ) lhs = new XorNode(lhs,null);
+            else break;
+            lhs.setDef(2,parseComparison());
+            lhs = peep(lhs);
+        }
+        return lhs;
+    }
+
+    /**
+     * Parse an expression of the form:
+     *
+     * <pre>
+     *     expr : additiveExpr op additiveExpr
+     * </pre>
+     * @return an comparator expression {@link Node}, never {@code null}
+     */
+    private Node parseComparison() {
+        var lhs = parseShift();
+        while( true ) {
+            int idx=0;  boolean negate=false;
+            // Test for any local nodes made, and "keep" lhs during peepholes
+            if( false ) ;
+            else if( match("==") ) { idx=2;  lhs = new BoolNode.EQ(lhs, null); }
+            else if( match("!=") ) { idx=2;  lhs = new BoolNode.EQ(lhs, null); negate=true; }
+            else if( match("<=") ) { idx=2;  lhs = new BoolNode.LE(lhs, null); }
+            else if( match("<" ) ) { idx=2;  lhs = new BoolNode.LT(lhs, null); }
+            else if( match(">=") ) { idx=1;  lhs = new BoolNode.LE(null, lhs); }
+            else if( match(">" ) ) { idx=1;  lhs = new BoolNode.LT(null, lhs); }
+            else break;
+            // Peepholes can fire, but lhs is already "hooked", kept alive
+            lhs.setDef(idx,parseShift());
+            lhs = peep(lhs.widen());
+            if( negate )        // Extra negate for !=
+                lhs = peep(new NotNode(lhs));
+        }
+        return lhs;
+    }
+
+    /**
+     * Parse an additive expression
+     *
+     * <pre>
+     *     shiftExpr : additiveExpr (('<<' | '>>' | '>>>') additiveExpr)*
+     * </pre>
+     * @return a shift expression {@link Node}, never {@code null}
+     */
+    private Node parseShift() {
+        Node lhs = parseAddition();
+        while( true ) {
+            if( false ) ;
+            else if( match("<<") ) lhs = new ShlNode(lhs,null);
+            else if( match(">>>")) lhs = new ShrNode(lhs,null);
+            else if( match(">>") ) lhs = new SarNode(lhs,null);
+            else break;
+            lhs.setDef(2,parseAddition());
+            lhs = peep(lhs.widen());
+        }
+        return lhs;
+    }
+
+    /**
+     * Parse an additive expression
+     *
+     * <pre>
+     *     additiveExpr : multiplicativeExpr (('+' | '-') multiplicativeExpr)*
+     * </pre>
+     * @return an add expression {@link Node}, never {@code null}
+     */
+    private Node parseAddition() {
+        Node lhs = parseMultiplication();
+        while( true ) {
+            if( false ) ;
+            else if( match("+") ) lhs = new AddNode(lhs,null);
+            else if( match("-") ) lhs = new SubNode(lhs,null);
+            else break;
+            lhs.setDef(2,parseMultiplication());
+            lhs = peep(lhs.widen());
+        }
+        return lhs;
+    }
+
+    /**
+     * Parse an multiplicativeExpr expression
+     *
+     * <pre>
+     *     multiplicativeExpr : unaryExpr (('*' | '/') unaryExpr)*
+     * </pre>
+     * @return a multiply expression {@link Node}, never {@code null}
+     */
+    private Node parseMultiplication() {
+        var lhs = parseUnary();  boolean mul;
+        while( true ) {
+            if( false ) ;
+            else if( match("*") ) lhs = new MulNode(lhs,null);
+            else if( match("/") ) lhs = new DivNode(lhs,null);
+            else break;
+            lhs.setDef(2,parseUnary());
+            lhs = peep(lhs.widen());
+        }
+        return lhs;
+    }
+
+    /**
+     * Parse a unary minus expression.
+     *
+     * <pre>
+     *     unaryExpr : ('-') unaryExpr | '!') unaryExpr | postfixExpr | primaryExpr | '--' Id | '++' Id
+     * </pre>
+     * @return a unary expression {@link Node}, never {@code null}
+     */
+    private Node parseUnary() {
+        // Pre-dec/pre-inc
+        int old = pos();
+        if( match("--") || match("++") ) {
+            int delta = _lexer.peek(-1)=='+' ? 1 : -1; // Pre vs post
+            String name = _lexer.matchId();
+            if( name!=null ) {
+                ScopeNode.Var n = _scope.lookup(name);
+                if( n != null ) {
+                    if( n._final )
+                        throw error("Cannot reassign final '"+n._name+"'");
+                    Node expr = zsMask(peep(new AddNode(_scope.in(n),con(delta))),n.type());
+                    _scope.update(n,expr);
+                    return expr;
+                }
+            }
+            // Reset, try again
+            pos(old);
+        }
+        if (match("-")) return peep(new MinusNode(parseUnary()).widen());
+        if (match("!")) return peep(new   NotNode(parseUnary()));
+        return parsePostfix(parsePrimary());
+    }
+
+    /**
+     * Parse a primary expression:
+     *
+     * <pre>
+     *     primaryExpr : integerLiteral | true | false | null | new Type | '(' expression ')' | Id['++','--']
+     * </pre>
+     * @return a primary {@link Node}, never {@code null}
+     */
+    private Node parsePrimary() {
+        if( _lexer.isNumber(_lexer.peek()) ) return parseLiteral();
+        if( matchx("true" ) ) return con(1);
+        if( matchx("false") ) return ZERO;
+        if( matchx("null" ) ) return con(TypeMemPtr.NULLPTR);
+        if( match("(") ) return require(parseAsgn(), ")");
+        if( matchx("new"  ) ) return alloc();
+        // Expect an identifier now
+        ScopeNode.Var n = requireLookupId("an identifier or expression");
+        Node rvalue = _scope.in(n);
+        if( rvalue._type == Type.BOTTOM )
+            throw error("Cannot read uninitialized field '"+n._name+"'");
+        // Check for assign-update, x += e0;
+        char ch = _lexer.matchOperAssign();
+        if( ch==0  ) return rvalue;
+        if( n._final )
+            throw error("Cannot reassign final '"+n._name+"'");
+        Node op = switch(ch) {
+        case '+'        -> new AddNode(rvalue,null);
+        case '-'        -> new SubNode(rvalue,null);
+        case '*'        -> new MulNode(rvalue,null);
+        case '/'        -> new DivNode(rvalue,null);
+        case '&'        -> new AndNode(rvalue,null);
+        case '|'        -> new  OrNode(rvalue,null);
+        case '^'        -> new XorNode(rvalue,null);
+        case Lexer.SHL  -> new ShlNode(rvalue,null);
+        case Lexer.SAR  -> new SarNode(rvalue,null);
+        case Lexer.SHR  -> new ShrNode(rvalue,null);
+        case        1   -> new AddNode(rvalue,con( 1));
+        case (char)-1   -> new AddNode(rvalue,con(-1));
+        default         -> throw Utils.TODO();
+        };
+        // Return pre-value (x+=1) or post-value (x++)
+        boolean pre = op.in(2)==null;
+        // Parse RHS argument as needed
+        if( pre )
+            { op.keep().setDef(2,parseAsgn());  op.unkeep(); }
+        else rvalue.keep();     // Keep post-value across peeps
+        op = zsMask(peep(op),n.type());
+        _scope.update(n,op);
+        return pre ? op : rvalue.unkeep();
+    }
+
+    ScopeNode.Var requireLookupId(String msg) {
+        String id = _lexer.matchId();
+        if( id == null || KEYWORDS.contains(id) )
+            throw errorSyntax(msg);
+        ScopeNode.Var n = _scope.lookup(id);
+        if( n==null )
+            throw error("Undefined name '" + id + "'");
+        return n;
+    }
+
+    /**
+       Parse an allocation
+     */
+    private Node alloc() {
+        Type t = type();
+        if( t==null ) throw error("Expected a type");
+        // Parse ary[ length_expr ]
+        if( match("[") ) {
+            Node len = parseAsgn();
+            if( !(len._type instanceof TypeInteger) )
+                throw error("Cannot allocate an array with length "+len._type);
+            require("]");
+            TypeMemPtr tmp = typeAry(t);
+            return newArray(tmp._obj,len);
+        }
+
+        if( !(t instanceof TypeMemPtr tmp) )
+            throw error("Cannot allocate a "+t.str());
+
+        // Parse new struct { default_initialization }
+        StructNode s = INITS.get(tmp._obj._name);
+        if( s==null ) throw error("Unknown struct type '" + tmp._obj._name + "'");
+
+        Field[] fs = s._ts._fields;
+        // if the object is fully initialized, we can skip a block here.
+        // Check for constructor block:
+        boolean hasConstructor = match("{");
+        Ary<Node> init=s._inputs;  int idx=0;
+        if( hasConstructor ) {
+            idx = _scope.nIns();
+            // Push a scope, and pre-assign all struct fields.
+            _scope.push();
+            for( int i=0; i<fs.length; i++ )
+                _scope.define(fs[i]._fname, fs[i]._type, fs[i]._final, s.in(i)._type==Type.TOP ? con(Type.BOTTOM) : s.in(i));
+            // Parse the constructor body
+            parseBlock(true);
+            require("}");
+            init = _scope._inputs;
+        }
+        // Check that all fields are initialized
+        for( int i=idx; i<init.size(); i++ )
+            if( init.at(i)._type == Type.TOP || init.at(i)._type == Type.BOTTOM )
+                throw error("'"+tmp._obj._name+"' is not fully initialized, field '" + fs[i-idx]._fname + "' needs to be set in a constructor");
+        Node ptr = newStruct(tmp._obj, con(tmp._obj.offset(fs.length)), idx, init );
+        if( hasConstructor )
+            _scope.pop();
+        return ptr;
+    }
+
+
+    /**
+     * Return a NewNode initialized memory.
+     * @param obj is the declared type, with GLB fields
+     * @param init is a collection of initialized fields
+     */
+    private Node newStruct( TypeStruct obj, Node size, int idx, Ary<Node> init ) {
+        Field[] fs = obj._fields;
+        if( fs==null )
+            throw error("Unknown struct type '" + obj._name + "'");
+        Node prior = mem().keep();
+        MemMergeNode input = new MemMergeNode(null);
+        for( Field f : fs ) input.alias(f._alias,prior);
+        // Constructor values follow control, memory, and allocation size.
+        Node[] ns = new Node[3+fs.length];
+        ns[0] = ctrl();
+        ns[1] = input.peephole();
+        ns[2] = size;
+        for( int i=0; i<fs.length; i++ ) ns[3+i] = init.get(idx+i);
+        Node nnn = new NewNode(TypeMemPtr.make(obj),ns).peephole().keep();
+        Node ptr = new ProjNode(nnn,0,obj._name).peephole().keep();
+        Node out = new ProjNode(nnn,1,"$mem").peephole().keep();
+        MemMergeNode after = new MemMergeNode(prior);
+        for( Field f : fs ) after.alias(f._alias,out);
+        mem(after.peephole());
+        out.unkeep();
+        nnn.unkeep();
+        prior.unkeep();
+        return ptr.unkeep();
+    }
+
+    private static final Ary<Node> ALTMP = new Ary<>(Node.class);
+    private Node newArray(TypeStruct ary, Node len) {
+        int base = ary.aryBase ();
+        int scale= ary.aryScale();
+        Node size = peep(new AddNode(con(base),peep(new ShlNode(len.keep(),con(scale)))));
+        ALTMP.clear();  ALTMP.add(len.unkeep()); ALTMP.add(con(ary._fields[1]._type.makeInit()));
+        return newStruct(ary,size,0,ALTMP);
+    }
+
+    // Memory is one hidden SSA variable, including across branches and loops.
+    private Node mem() { return _scope.mem(); }
+    private void mem(Node n) { _scope.mem(n); }
+
+    private void store(String name, int alias, Type glb, Node ptr, Node off, Node val, boolean init, Node ctrl) {
+        if( !init && ptr._type instanceof TypeMemPtr view && view._ro && ctrl()._type!=Type.XCONTROL )
+            throw error("Cannot modify final field '"+name+"'");
+        Node prior = mem().keep();
+        Node st = new StoreNode(name,alias,glb,prior,ptr,off,val,init);
+        st.setDef(0,ctrl);
+        st = st.peephole();
+        mem(new MemMergeNode(prior,alias,st).peephole());
+        prior.unkeep();
+    }
+
+    /**
+     * Parse postfix expression. For now this is just a field
+     * expression, but in future could be array index too.
+     *
+     * <pre>
+     *     expr ('.' IDENTIFIER)* [ = expr ]
+     *     expr #
+     *     expr ('[' expr ']')* = [ = expr ]
+     * </pre>
+     */
+    private Node parsePostfix(Node expr) {
+        String name = null;
+        if( match(".") )      name = requireId();
+        else if( match("#") ) name = "#";
+        else if( match("[") ) name = "[]";
+        else return expr;       // No postfix
+
+        // Sanity check expr for being a reference
+        if( !(expr._type instanceof TypeMemPtr ptr) )
+            throw error("Expected reference but got " + expr._type.str());
+
+        // Happens when parsing known dead code, which often has other typing
+        // issues.  Since the code is dead, possibly due to inlining, lets not
+        // spoil the user experience with error messages.
+        if( ctrl()._type==Type.XCONTROL )
+            // Exit out via parsing the trailing expression
+            return matchOpx('=','=') ? parseAsgn() : parsePostfix(con(Type.TOP));
+
+        // Sanity check field name for existing
+        TypeMemPtr tmp = (TypeMemPtr)TYPES.get(ptr._obj._name);
+        if( tmp == null ) throw error("Accessing unknown field '" + name + "' from '" + ptr + "'");
+        TypeStruct base = ptr._obj.isAry() ? ptr._obj : tmp._obj;
+        int fidx = base.find(name);
+        if( fidx == -1 ) throw error("Accessing unknown field '" + name + "' from '" + ptr.str() + "'");
+
+        // Get field type and layout offset from base type and field index fidx
+        Field f = base._fields[fidx];  // Field from field index
+        Type tf = f._type;
+        if( tf instanceof TypeMemPtr ftmp && ftmp.isFRef() )
+            tf = ftmp.makeFrom(((TypeMemPtr)(TYPES.get(ftmp._obj._name)))._obj);
+
+        expr.keep();
+        // Field offset; fixed for structs, computed for arrays
+        Node off = (name.equals("[]")       // If field is an array body
+            // Array index math
+            ? peep(new AddNode(con(base.aryBase()),peep(new ShlNode(require(parseAsgn(),"]"),con(base.aryScale())))))
+            // Struct field offsets are hardwired
+            : con(base.offset(fidx))).keep();
+
+        // Disambiguate "obj.fld==x" boolean test from "obj.fld=x" field assignment
+        if( matchOpx('=','=') ) {
+            Node val = parseAsgn().keep();
+            Node lift = liftExpr( val, tf );
+
+            store(name,f._alias,tf,expr.unkeep(),off.unkeep(),lift,false,base.isAry() ? ctrl() : null);
+            return val.unkeep();        // "obj.a = expr" returns the expression while updating memory
+        }
+
+        Node load = new LoadNode(name, f._alias, (tf instanceof TypeMemPtr ? tf : tf.glb()), mem(), expr, off);
+        // Arrays include control, as a proxy for a safety range check
+        // Structs don't need this; they only need a NPE check which is
+        // done via the type system.
+        if( base.isAry() ) load.setDef(0,ctrl());
+        load = peep(load);
+
+        // ary[idx]++ or ptr.fld++
+        if( matchx("++") || matchx("--") ) {
+            if( f._final && !f._fname.equals("[]") )
+                throw error("Cannot reassign final '"+f._fname+"'");
+            Node inc = peep(new AddNode(load,con( _lexer.peek(-1)=='+' ? 1 : -1)));
+            Node val = zsMask(inc,tf);
+            store(name,f._alias,tf,expr.unkeep(),off,val,false,base.isAry() ? ctrl() : null);
+            // And use the original loaded value as the result
+        } else expr.unkill();
+        off.unkill();
+
+        return parsePostfix(load);
+    }
+
+
+    // zero/sign extend.  "i" is limited to either classic unsigned (min==0) or
+    // classic signed (min=minus-power-of-2); max=power-of-2-minus-1.
+    private Node zsMask(Node val, Type t ) {
+        if( !(val._type instanceof TypeInteger tval && t instanceof TypeInteger t0 && !tval.isa(t0)) ) {
+            if( !(val._type instanceof TypeFloat tval && t instanceof TypeFloat t0 && !tval.isa(t0)) )
+                return val;
+            // Float rounding
+            return peep(new RoundF32Node(val));
+        }
+        if( t0._min==0 )        // Unsigned
+            return peep(new AndNode(val,con(t0._max)));
+        // Signed extension
+        int shift = Long.numberOfLeadingZeros(t0._max)-1;
+        Node shf = con(shift);
+        if( shf._type==TypeInteger.ZERO )
+            return val;
+        return peep(new SarNode(peep(new ShlNode(val,shf.keep())),shf.unkeep()));
+    }
+
+
+    /**
+     * Parse integer literal
+     *
+     * <pre>
+     *     integerLiteral: [1-9][0-9]* | [0]
+     *     floatLiteral: [digits].[digits]?[e [digits]]?
+     * </pre>
+     */
+    private ConstantNode parseLiteral() { return con(_lexer.parseNumber()); }
+    public static Node con( long con ) { return con(TypeInteger.constant(con));  }
+    public static ConstantNode con( Type t ) { return (ConstantNode)new ConstantNode(t).peephole();  }
+    public Node peep( Node n ) {
+        // Peephole, then improve with lexically scoped guards
+        return _scope.upcastGuard(n.peephole());
+    }
+
+    //////////////////////////////////
+    // Utilities for lexical analysis
+
+    // Return true and skip if "syntax" is next in the stream.
+    private boolean match (String syntax) { return _lexer.match (syntax); }
+    // Match must be "exact", not be followed by more id letters
+    private boolean matchx(String syntax) { return _lexer.matchx(syntax); }
+    private boolean matchOpx(char c0, char c1) { return _lexer.matchOpx(c0,c1);  }
+    // Return true and do NOT skip if 'ch' is next
+    private boolean peek(char ch) { return _lexer.peek(ch); }
+    private boolean peekIsId() { return _lexer.peekIsId(); }
+
+    private int pos(int pos) {
+        int old = _lexer._position;
+        _lexer._position = pos;
+        return old;
+    }
+    private Type posT(int pos) { _lexer._position = pos; return null; }
+
+    // Require and return an identifier
+    private String requireId() {
+        String id = _lexer.matchId();
+        if (id != null && !KEYWORDS.contains(id) ) return id.intern();
+        throw error("Expected an identifier, found '"+id+"'");
+    }
+
+    private String matchId() {
+        int old = pos();
+        String id = _lexer.matchId();
+        if( id==null ) return null;
+        if( !KEYWORDS.contains(id) ) return id;
+        pos(old);
+        return null;
+    }
+
+    // Require an exact match
+    private Parser require(String syntax) { require(null, syntax); return this; }
+    private <N> N require(N n, String syntax) {
+        if (match(syntax)) return n;
+        throw errorSyntax(syntax);
+    }
+
+    RuntimeException errorSyntax(String syntax) {
+        return error("Syntax error, expected " + syntax + ": " + _lexer.getAnyNextToken());
+    }
+
+    public static RuntimeException error( String errorMessage ) {
+        return new RuntimeException(errorMessage);
+    }
+
+    ////////////////////////////////////
+    // Lexer components
+
+    private static class Lexer {
+
+        // Input buffer; an array of text bytes read from a file or a string
+        private final byte[] _input;
+        // Tracks current position in input buffer
+        private int _position = 0;
+
+        /**
+         * Record the source text for lexing
+         */
+        public Lexer(String source) {
+            this(source.getBytes());
+        }
+
+        /**
+         * Direct from disk file source
+         */
+        public Lexer(byte[] buf) {
+            _input = buf;
+        }
+
+        // Very handy in the debugger, shows the unparsed program
+        @Override
+        public String toString() {
+            return new String(_input, _position, _input.length - _position);
+        }
+
+        // True if at EOF
+        private boolean isEOF() {
+            return _position >= _input.length;
+        }
+
+        // Peek next character, or report EOF
+        private char peek() {
+            return isEOF() ? Character.MAX_VALUE   // Special value that causes parsing to terminate
+                    : (char) _input[_position];
+        }
+        // Just crash if misused
+        public byte peek(int off) { return _input[_position+off]; }
+
+        private char nextChar() {
+            char ch = peek();
+            _position++;
+            return ch;
+        }
+
+        // True if a white space
+        private boolean isWhiteSpace() {
+            return peek() <= ' '; // Includes all the use space, tab, newline, CR
+        }
+
+        /**
+         * Return the next non-white-space character
+         */
+        private void skipWhiteSpace() {
+            while( true ) {
+                if( isWhiteSpace() ) _position++;
+                // Skip // to end of line
+                else if( _position+2 < _input.length &&
+                         _input[_position  ] == '/' &&
+                         _input[_position+1] == '/') {
+                    _position += 2;
+                    while( !isEOF() && _input[_position] != '\n' ) _position++;
+                } else break;
+            }
+        }
+
+        // Next non-white-space character, or EOF
+        public char nextXChar() { skipWhiteSpace(); return nextChar(); }
+
+        // Return true, if we find "syntax" after skipping white space; also
+        // then advance the cursor past syntax.
+        // Return false otherwise, and do not advance the cursor.
+        boolean match(String syntax) {
+            skipWhiteSpace();
+            int len = syntax.length();
+            if (_position + len > _input.length) return false;
+            for (int i = 0; i < len; i++)
+                if ((char) _input[_position + i] != syntax.charAt(i))
+                    return false;
+            _position += len;
+            return true;
+        }
+
+        // Match must be exact and not followed by more ID characters.
+        // Prevents identifier "ifxy" from matching an "if" statement.
+        boolean matchx(String syntax) {
+            if( !match(syntax) ) return false;
+            if( !isIdLetter(peek()) ) return true;
+            _position -= syntax.length();
+            return false;
+        }
+        boolean matchOpx(char c0, char c1) {
+            skipWhiteSpace();
+            if( _position+1 >= _input.length || _input[_position]!=c0 || _input[_position+1]==c1 )
+                return false;
+            _position++;
+            return true;
+        }
+
+        private boolean peek(char ch) {
+            skipWhiteSpace();
+            return peek()==ch;
+        }
+
+        boolean peekIsId() {
+            skipWhiteSpace();
+            return isIdStart(peek());
+        }
+
+        // Return an identifier or null
+        String matchId() {
+            return peekIsId() ? parseId() : null;
+        }
+
+        // Used for errors
+        String getAnyNextToken() {
+            if (isEOF()) return "";
+            if (isIdStart(peek())) return parseId();
+            if (isNumber(peek())) return parseNumberString();
+            if (isPunctuation(peek())) return parsePunctuation();
+            return String.valueOf(peek());
+        }
+
+
+        boolean isNumber(char ch) {return Character.isDigit(ch);}
+
+        // Return a constant Type, either TypeInteger or TypeFloat
+        private Type parseNumber() {
+            int old = _position;
+            int len = isLongOrDouble();
+            if( len > 0 ) {
+                if( len > 1 && _input[old]=='0' )
+                    throw error("Syntax error: integer values cannot start with '0'");
+                return TypeInteger.constant(Long.parseLong(new String(_input,old,len)));
+            }
+            return TypeFloat.constant(Double.parseDouble(new String(_input,old,-len)));
+        }
+        private String parseNumberString() {
+            int old = _position;
+            int len = Math.abs(isLongOrDouble());
+            _position += len;
+            return new String(_input,old,len);
+        }
+
+        // Return +len that ends a long
+        // Return -len that ends a double
+        private int isLongOrDouble() {
+            int old = _position;
+            char c;
+            while( Character.isDigit(c=nextChar()) ) ;
+            if( !(c=='e' || c=='.') )
+                return --_position - old;
+            while( Character.isDigit(c=nextChar()) || c=='e' || c=='.' ) ;
+            return -(--_position - old);
+        }
+
+        // First letter of an identifier
+        private boolean isIdStart(char ch) {
+            return Character.isAlphabetic(ch) || ch == '_';
+        }
+
+        // All characters of an identifier, e.g. "_x123"
+        private boolean isIdLetter(char ch) {
+            return Character.isLetterOrDigit(ch) || ch == '_';
+        }
+
+        private String parseId() {
+            int start = _position;
+            while (isIdLetter(nextChar())) ;
+            return new String(_input, start, --_position - start);
+        }
+
+        //
+        private boolean isPunctuation(char ch) {
+            return "=;[]<>()+-/*&|^".indexOf(ch) != -1;
+        }
+
+        private String parsePunctuation() {
+            int start = _position;
+            return new String(_input, start, 1);
+        }
+
+        // Next oper= character, or 0.
+        // As a convenience, mark "++" as a char 1 and "--" as char -1 (65535)
+        // Disallow e.g. "arg--1" which should parse as "arg - -1"
+        // Distinct tags for the multi-character compound operators.
+        static final char SHL = 2, SAR = 3, SHR = 4;
+
+        public char matchOperAssign() {
+            skipWhiteSpace();
+            if( match("<<=" ) ) return SHL;
+            if( match(">>>=") ) return SHR;
+            if( match(">>=" ) ) return SAR;
+            if( _position+2 >= _input.length ) return 0;
+            char ch0 = (char)_input[_position];
+            if( "+-/*&|^".indexOf(ch0) == -1 ) return 0;
+            char ch1 = (char)_input[_position+1];
+            if(               ch1 == '=' ) { _position += 2; return ch0; }
+            if( isIdLetter((char)_input[_position+2]) ) return 0;
+            if( ch0 == '+' && ch1 == '+' ) { _position += 2; return (char) 1; }
+            if( ch0 == '-' && ch1 == '-' ) { _position += 2; return (char)-1; }
+            return 0;
+        }
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/Utils.java b/chapter17b/src/main/java/com/seaofnodes/simple/Utils.java
new file mode 100644
index 00000000..1346c3ea
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/Utils.java
@@ -0,0 +1,53 @@
+package com.seaofnodes.simple;
+
+import java.util.ArrayList;
+
+public class Utils {
+    public static RuntimeException TODO() { return TODO("Not yet implemented"); }
+    public static RuntimeException TODO(String msg) { return new RuntimeException(msg); }
+
+    /**
+     *  Fast, constant-time, element removal.  Does not preserve order
+     *
+     *  @param array ArrayList to modify
+     *  @param i element to be removed
+     *  @return element removed
+     */
+    public static <E> void del(ArrayList<E> array, int i) {
+        E last = array.removeLast();
+        if (i < array.size()) array.set(i, last);
+    }
+
+    /**
+     * Search a list for an element by reference
+     *
+     * @param ary List to search in
+     * @param x Object to be searched
+     * @return >= 0 on success, -1 on failure
+     */
+    public static <E> int find( ArrayList<E> ary, E x ) {
+        for( int i=0; i<ary.size(); i++ )
+            if( ary.get(i)==x )
+                return i;
+        return -1;
+    }
+    /**
+     * Search a list for an element by reference
+     *
+     * @param ary List to search in
+     * @param x Object to be searched
+     * @return >= 0 on success, -1 on failure
+     */
+    public static <E> int find( E[] ary, E x ) {
+        for( int i=0; i<ary.length; i++ )
+            if( ary[i]==x )
+                return i;
+        return -1;
+    }
+
+    // Rotate a long, nice for hashes
+    public static long rot( long x, int n ) { return (x<<n) | (x>>>n); }
+
+    // Fold a 64bit hash into 32 bits
+    public static int fold( long x ) { return (int)((x>>32) ^ x); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/AddFNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/AddFNode.java
new file mode 100644
index 00000000..fd713156
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/AddFNode.java
@@ -0,0 +1,37 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+
+
+public class AddFNode extends Node {
+    public AddFNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "AddF"; }
+
+    @Override protected String format() { return "(%1+%2)"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeFloat i0 &&
+            in(2)._type instanceof TypeFloat i1) {
+            if (i0.isConstant() && i1.isConstant())
+                return TypeFloat.constant(i0.value()+i1.value());
+        }
+        return in(1)._type.meet(in(2)._type);
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Type t2 = in(2)._type;
+
+        // Add of 0.
+        if ( t2.isConstant() && t2 instanceof TypeFloat i && i.value()==0 )
+            return lhs;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new AddFNode(lhs,rhs); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/AddNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/AddNode.java
new file mode 100644
index 00000000..5eb0b0a3
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/AddNode.java
@@ -0,0 +1,186 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.*;
+
+
+public class AddNode extends Node {
+    public AddNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Add"; }
+
+    @Override protected String format() { return "(%1+%2)"; }
+
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i1 &&
+            t2 instanceof TypeInteger i2 ) {
+            if (i1.isConstant() && i2.isConstant())
+                return TypeInteger.constant(i1.value()+i2.value());
+            // Fold ranges like {0-1} + {2-3} into {2-4}.
+            if( !overflow(i1._min,i2._min) &&
+                !overflow(i1._max,i2._max) )
+                return TypeInteger.make(i1._min+i2._min,i1._max+i2._max);
+        }
+        return TypeInteger.BOT;
+    }
+
+    static boolean overflow( long x, long y ) {
+        if( (x ^    y ) < 0 ) return false; // unequal signs, never overflow
+        return (x ^ (x + y)) < 0; // sum has unequal signs, so overflow
+    }
+    @Override
+    public Node idealize () {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        if( rhs.err() != null ) return null;
+        Type t2 = rhs._type;
+
+        // Add of 0.  We do not check for (0+x) because this will already
+        // canonicalize to (x+0)
+        if( t2 instanceof TypeInteger i && i.isConstant() && i.value()==0 )
+            return lhs;
+
+        // Add of same to a multiply by 2
+        if( lhs==rhs )
+            return new MulNode(lhs,new ConstantNode(TypeInteger.constant(2)).peephole());
+
+        // Goal: a left-spine set of adds, with constants on the rhs (which then fold).
+
+        // Move non-adds to RHS
+        if( !(lhs instanceof AddNode) && rhs instanceof AddNode )
+            return swap12();
+
+        // x+(-y) becomes x-y
+        if( rhs instanceof MinusNode minus )
+            return new SubNode(lhs,minus.in(1));
+
+        // Now we might see (add add non) or (add non non) or (add add add) but never (add non add)
+
+        // Do we have  x + (y + z) ?
+        // Swap to    (x + y) + z
+        // Rotate (add add add) to remove the add on RHS
+        if( rhs instanceof AddNode add )
+            return new AddNode(new AddNode(lhs,add.in(1)).peephole(), add.in(2));
+
+        // Now we might see (add add non) or (add non non) but never (add non add) nor (add add add)
+        if( !(lhs instanceof AddNode) )
+            // Rotate; look for (add (phi cons) con/(phi cons))
+            return spine_cmp(lhs,rhs,this) ? swap12() : phiCon(this,true);
+
+        // Now we only see (add add non)
+
+        // Dead data cycle; comes about from dead infinite loops.  Do nothing,
+        // the loop will peep as dead after a bit.
+        if( lhs.in(1) == lhs )
+            return null;
+
+        // Do we have (x + con1) + con2?
+        // Replace with (x + (con1+con2) which then fold the constants
+        // lhs.in(2) is con1 here
+        // If lhs.in(2) is not a constant, we add ourselves as a dependency
+        // because if it later became a constant then we could make this
+        // transformation.
+        if( lhs.in(2).addDep(this)._type.isConstant() && rhs._type.isConstant() )
+            return new AddNode(lhs.in(1),new AddNode(lhs.in(2),rhs).peephole());
+
+
+        // Do we have ((x + (phi cons)) + con) ?
+        // Do we have ((x + (phi cons)) + (phi cons)) ?
+        // Push constant up through the phi: x + (phi con0+con0 con1+con1...)
+        Node phicon = phiCon(this,true);
+        if( phicon!=null ) return phicon;
+
+        // Now we sort along the spine via rotates, to gather similar things together.
+
+        // Do we rotate (x + y) + z
+        // into         (x + z) + y ?
+        if( spine_cmp(lhs.in(2),rhs,this) )
+            return new AddNode(new AddNode(lhs.in(1),rhs).peephole(),lhs.in(2));
+
+        return null;
+    }
+
+    // Rotation is only valid for associative ops, e.g. Add, Mul, And, Or, Xor.
+    // Do we have ((phi cons)|(x + (phi cons)) + con|(phi cons)) ?
+    // Push constant up through the phi: x + (phi con0+con0 con1+con1...)
+    static Node phiCon(Node op, boolean rotate) {
+        Node lhs = op.in(1);
+        Node rhs = op.in(2);
+        if( rhs._type==TypeInteger.TOP ) return null;
+        // LHS is either a Phi of constants, or another op with Phi of constants
+        PhiNode lphi = pcon(lhs,op);
+        if( rotate && lphi==null && lhs.nIns() > 2 ) {
+            // Only valid to rotate constants if both are same associative ops
+            if( lhs.getClass() != op.getClass() ) return null;
+            lphi = pcon(lhs.in(2),op); // Will rotate with the Phi push
+        }
+        if( lphi==null ) return null;
+
+        // RHS is a constant or a Phi of constants
+        if( !(rhs instanceof ConstantNode) && pcon(rhs,op)==null )
+            return null;
+
+        // If both are Phis, must be same Region
+        if( rhs instanceof PhiNode && lphi.in(0) != rhs.in(0) )
+            return null;
+
+        // Note that this is the exact reverse of Phi pulling a common op down
+        // to reduce total op-count.  We don't get in an endless push-up
+        // push-down peephole cycle because the constants all fold first.
+        Node[] ns = new Node[lphi.nIns()];
+        ns[0] = lphi.in(0);
+        // Push constant up through the phi: x + (phi con0+con0 con1+con1...)
+        for( int i=1; i<ns.length; i++ )
+            ns[i] = op.copy(lphi.in(i), rhs instanceof PhiNode ? rhs.in(i) : rhs).peephole();
+        String label = lphi._label + (rhs instanceof PhiNode rphi ? rphi._label : "");
+        Node phi = new PhiNode(label,lphi._declaredType,ns).peephole();
+        // Rotate needs another op, otherwise just the phi
+        return lhs==lphi ? phi : op.copy(lhs.in(1),phi);
+    }
+
+    /**
+     * Tests if the op is a phi and has all constant inputs.
+     * If not, returns null.
+     * If op is a phi, but its inputs are not all constants, then dep is added as
+     * a dependency to the phi's non-const input, because if later the input turn into a constant
+     * dep can make progress.
+     */
+    static PhiNode pcon(Node op, Node dep) {
+        return op instanceof PhiNode phi && phi.allCons(dep) ? phi : null;
+    }
+
+    // Compare two off-spine nodes and decide what order they should be in.
+    // Do we rotate ((x + hi) + lo) into ((x + lo) + hi) ?
+    // Generally constants always go right, then Phi-of-constants, then muls, then others.
+    // Ties with in a category sort by node ID.
+    // TRUE if swapping hi and lo.
+    static boolean spine_cmp( Node hi, Node lo, Node dep ) {
+        if( lo._type.isConstant() ) return false;
+        if( hi._type.isConstant() ) return true ;
+
+        if( lo instanceof PhiNode lphi && lphi.region()._type==Type.XCONTROL ) return false;
+        if( hi instanceof PhiNode hphi && hphi.region()._type==Type.XCONTROL ) return false;
+
+        if( lo instanceof PhiNode && lo.allCons(dep) ) return false;
+        if( hi instanceof PhiNode && hi.allCons(dep) ) return true ;
+
+        if( lo instanceof PhiNode && !(hi instanceof PhiNode) ) return true;
+        if( hi instanceof PhiNode && !(lo instanceof PhiNode) ) return false;
+
+        // Same category of "others"
+        return lo._nid > hi._nid;
+    }
+
+    @Override Node copy(Node lhs, Node rhs) { return new AddNode(lhs,rhs); }
+    @Override Node copyF() { return new AddFNode(null,null); }
+    @Override public String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '"+label()+"' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '"+label()+"' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/AndNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/AndNode.java
new file mode 100644
index 00000000..bd03d6cb
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/AndNode.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class AndNode extends Node {
+    public AndNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "And"; }
+
+    @Override protected String format() { return "(%1&%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i0 &&
+            t2 instanceof TypeInteger i1 ) {
+            if( i0.isConstant() && i1.isConstant() )
+                return TypeInteger.constant(i0.value()&i1.value());
+            // Sharpen allowed bits if either value is narrowed
+            long mask = i0.mask() & i1.mask();
+            return mask < 0 ? TypeInteger.BOT : TypeInteger.make(0,mask);
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // And of -1.  We do not check for (-1&x) because this will already
+        // canonicalize to (x&-1)
+        if( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==-1 )
+            return lhs;
+
+        // Move constants to RHS: con*arg becomes arg*con
+        if ( t1.isConstant() && !t2.isConstant() )
+            return swap12();
+
+        // Do we have ((x & (phi cons)) & con) ?
+        // Do we have ((x & (phi cons)) & (phi cons)) ?
+        // Push constant up through the phi: x & (phi con0&con0 con1&con1...)
+        Node phicon = AddNode.phiCon(this,true);
+        if( phicon!=null ) return phicon;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new AndNode(lhs,rhs); }
+    @Override String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '&' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '&' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/BoolNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/BoolNode.java
new file mode 100644
index 00000000..6efde623
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/BoolNode.java
@@ -0,0 +1,114 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeFloat;
+import com.seaofnodes.simple.type.TypeMemPtr;
+
+import static com.seaofnodes.simple.type.TypeInteger.*;
+
+abstract public class BoolNode extends Node {
+
+    public BoolNode(Node lhs, Node rhs) {
+        super(null, lhs, rhs);
+    }
+
+    abstract String op();       // String opcode name
+
+    @Override
+    public String label() { return getClass().getSimpleName(); }
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.open().n(in(1)).p(op()).n(in(2)).close();
+    }
+
+    @Override
+    public TypeInteger compute() {
+        Type t1 = in(1)._type;
+        Type t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return BOOL.dual();
+        if( t1 instanceof TypeInteger i1 &&
+            t2 instanceof TypeInteger i2 )
+            return doOp(i1,i2);
+        if( t1 instanceof TypeFloat f1 &&
+            t2 instanceof TypeFloat f2 &&
+            f1.isConstant() && f2.isConstant() )
+            return TypeInteger.constant(doOp(f1.value(), f2.value()) ? 1 : 0);
+        return BOOL;
+    }
+
+    TypeInteger doOp(TypeInteger t1, TypeInteger t2) { throw Utils.TODO(); }
+    boolean doOp(double lhs, double rhs) { throw Utils.TODO(); }
+
+    @Override
+    public Node idealize() {
+        // Compare of same
+        if( in(1)==in(2) )
+            return new ConstantNode(doOp(ZERO,ZERO));
+
+        // Equals pushes constant to the right; 5==X becomes X==5.
+        if( this instanceof EQ ) {
+            if( !(in(2) instanceof ConstantNode) ) {
+                // con==noncon becomes noncon==con
+                if( in(1) instanceof ConstantNode || in(1)._nid > in(2)._nid )
+                // Equals sorts by NID otherwise: non.high == non.low becomes non.low == non.high
+                    return in(1)._type instanceof TypeFloat ? new EQF(in(2),in(1)) : new EQ(in(2),in(1));
+            }
+            // Equals X==0 becomes a !X
+            if( (in(2)._type == ZERO || in(2)._type == TypeMemPtr.NULLPTR) )
+                return new NotNode(in(1));
+        }
+
+        // Do we have ((phi cons) cmp con) ?
+        // Do we have ((phi cons) cmp (phi cons)) ?
+        // Push the compare up through the phi: (phi con0 cmp con, con1 cmp con...)
+        Node phicon = AddNode.phiCon(this,this instanceof EQ);
+        if( phicon!=null ) return phicon;
+
+        return null;
+    }
+
+    public static class EQ extends BoolNode {
+        public EQ(Node lhs, Node rhs) { super(lhs,rhs); }
+        String op() { return "=="; }
+        TypeInteger doOp(TypeInteger i1, TypeInteger i2) {
+            if( i1==i2 && i1.isConstant() ) return TRUE;
+            if( i1._max < i2._min || i1._min > i2._max ) return FALSE;
+            return BOOL;
+        }
+        Node copy(Node lhs, Node rhs) { return new EQ(lhs,rhs); }
+        Node copyF() { return new EQF(null,null); }
+    }
+    public static class LT extends BoolNode {
+        public LT(Node lhs, Node rhs) { super(lhs,rhs); }
+        String op() { return "<" ; }
+        TypeInteger doOp(TypeInteger i1, TypeInteger i2) {
+            if( i1._max <  i2._min ) return TRUE;
+            if( i1._min >= i2._max ) return FALSE;
+            return BOOL;
+        }
+        Node copy(Node lhs, Node rhs) { return new LT(lhs,rhs); }
+        Node copyF() { return new LTF(null,null); }
+    }
+    public static class LE extends BoolNode {
+        public LE(Node lhs, Node rhs) { super(lhs,rhs); }
+        String op() { return "<="; }
+        TypeInteger doOp(TypeInteger i1, TypeInteger i2) {
+            if( i1._max <= i2._min ) return TRUE;
+            if( i1._min >  i2._max ) return FALSE;
+            return BOOL;
+        }
+        Node copy(Node lhs, Node rhs) { return new LE(lhs,rhs); }
+        Node copyF() { return new LEF(null,null); }
+    }
+
+    public static class EQF extends EQ { public EQF(Node lhs, Node rhs) { super(lhs,rhs); } boolean doOp(double lhs, double rhs) { return lhs == rhs; } }
+    public static class LTF extends LT { public LTF(Node lhs, Node rhs) { super(lhs,rhs); } boolean doOp(double lhs, double rhs) { return lhs <  rhs; } }
+    public static class LEF extends LE { public LEF(Node lhs, Node rhs) { super(lhs,rhs); } boolean doOp(double lhs, double rhs) { return lhs <= rhs; } }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
new file mode 100644
index 00000000..84f97189
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
@@ -0,0 +1,237 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMem;
+import java.util.BitSet;
+
+/**
+ * A Phi for bulk memory.  It covers all aliases except {@link #_aliases};
+ * those aliases must be represented by parallel precise MemPhis at the same
+ * program slice.
+ */
+public class BulkMemPhiNode extends PhiNode {
+
+    private static final BitSet EMPTY = new BitSet();
+
+    // Excluded Aliases; empty means NO exclusions.
+    // Each split clones the exclusions; published sets are never mutated.
+    public final BitSet _aliases;
+
+    public BulkMemPhiNode(String label, Node... inputs) {
+        this(label,EMPTY,inputs);
+    }
+
+    private BulkMemPhiNode(String label, BitSet aliases, Node... inputs) {
+        super(label,TypeMem.BOT,inputs);
+        _aliases = aliases;
+    }
+
+    public boolean isSplit(int alias) { return _aliases.get(alias); }
+
+    @Override public String label() { return "BulkPhi"+_aliases; }
+
+    @Override
+    public Type compute() {
+        Type t = super.compute();
+        return t instanceof TypeMem mem ? mem :
+            t==Type.BOTTOM ? TypeMem.BOT :
+            TypeMem.TOP;
+    }
+
+    @Override
+    public Node idealize() {
+        Node progress = super.idealize();
+        if( progress != null ) return progress;
+        if( ((RegionNode)region()).inProgress() || region().nIns()<=1 )
+            return null;        // Input is in-progress
+
+        // "Peek through" a MemMerge that covers this alias set on its default
+        for( int i=1; i<nIns(); i++ )
+            if( in(i) instanceof MemMergeNode mmm && canPeek(mmm) ) {
+                setDef(i,IterPeeps.add(mmm.in(1)));
+                return this;
+            }
+
+        // If any input or output uses or defines a specific alias we cover,
+        // make a private MemPhi for it, and add it to the excluded list.
+        for( int i=1; i<nIns(); i++ ) {
+            int alias = inputAlias(in(i));
+            if( alias!=0 )
+                return slice(alias);
+        }
+
+        for( int i=0; i<_outputs.size(); i++ ) {
+            int alias = outputAlias(_outputs.get(i));
+            if( alias!=0 )
+                return slice(alias);
+        }
+
+        return null;
+    }
+
+    static public boolean checkMem(Node n, int alias) {
+        for( Node m : n._inputs )
+            // Bulk memory supplies this alias
+            if( m instanceof BulkMemPhiNode bulk ) {
+                if( bulk._aliases.get(alias) )
+                    return false;
+            } else if( m instanceof MemMergeNode mmm &&
+                       mmm.in(1) instanceof BulkMemPhiNode bulk &&
+                       bulk._aliases.get(alias) &&
+                       (alias >= mmm.nIns() || mmm.in(alias)==null) )
+                return false;
+        return true;
+    }
+
+
+    // True if the MemMerge has no precise slice still covered by this Phi.
+    private boolean canPeek(MemMergeNode mmm) {
+        return mmm.in(1)!=null && missingAlias(mmm)==0;
+    }
+
+    // Return an alias required by an input but still covered by this Phi, or 0.
+    private int inputAlias(Node n) {
+        return switch(n) {
+        case ProjNode proj -> 0;
+        case ConstantNode con -> 0;
+        case MemMergeNode mmm -> missingAlias(mmm);
+        case MemOpNode mem -> unsplit(mem._alias);
+        case BulkMemPhiNode bulk -> missingAlias(bulk);
+        default -> throw new AssertionError("Unexpected memory input "+n);
+        };
+    }
+
+    // Return an alias required by a user but still covered by this Phi, or 0.
+    private int outputAlias(Node use) {
+        // This decision depends backwards on an immediate user's alias/set.
+        // Normal graph-neighbor enqueueing flows from defs to uses, so retain
+        // an explicit forward dependency to revisit this Phi when the user
+        // sharpens.
+        use.addDepForwards(this);
+        return switch(use) {
+        case ScopeNode scope -> 0;
+        case MemMergeNode mmm -> missingAlias(mmm);
+        case BulkMemPhiNode bulk -> missingAlias(bulk);
+        case MemOpNode mem -> unsplit(mem._alias);
+        case MemPhiNode phi -> unsplit(phi._alias);
+        default -> {
+            assert use instanceof ReturnNode
+                : "Unexpected bulk-memory user "+use;
+            yield 0;
+        }
+        };
+    }
+
+    // Alias zero/one is bulk, and an already excluded precise alias cannot
+    // trigger another split of this Phi.
+    private int unsplit(int alias) {
+        if( alias <= 1 ) return 0;
+        assert !_aliases.get(alias);
+        return alias;
+    }
+
+    // First alias excluded by the neighboring bulk Phi but not by this one.
+    private int missingAlias(BulkMemPhiNode bulk) {
+        for( int alias = bulk._aliases.nextSetBit(0); alias >= 0; alias = bulk._aliases.nextSetBit(alias+1) )
+            if( !_aliases.get(alias) )
+                return alias;
+        return 0;
+    }
+
+    // Every explicit slot requests that alias, including a partial allocation
+    // input whose slot still points to this bulk Phi.
+    private int missingAlias(MemMergeNode mmm) {
+        for( int alias=2; alias<mmm.nIns(); alias++ )
+            if( mmm.in(alias)!=null &&
+                mmm.alias(alias)!=mmm.in(1) &&
+                !_aliases.get(alias) )
+                return alias;
+        return 0;
+    }
+
+    // Slice out given alias
+    private MemMergeNode slice( int alias ) {
+        assert !_aliases.get(alias);
+        // Inputs are the same; MemPhi will sharpen his own inputs.  If a
+        // parallel precise Phi already exists, reuse it instead of building a
+        // duplicate for the same Region/alias pair.
+        Node mem = precisePhi(alias);
+
+        BitSet aliases = ((BitSet)_aliases.clone());
+        aliases.set(alias);
+        BulkMemPhiNode bphi = new BulkMemPhiNode(_label,aliases);
+        for( int i=0; i<nIns(); i++ )
+            bphi.addDef(in(i));
+        // Installing bphi creates a new bulk user with a different exclusion
+        // set.  Queue the original memory inputs before bphi itself can peep
+        // away and hide those neighbor relationships.
+        for( int i=1; i<bphi.nIns(); i++ )
+            IterPeeps.add(bphi.in(i));
+        // Do not peephole bphi here, as BulkMemPhi can recursively start a
+        // second bulk rewrite before this one has finished.  Let the worklist
+        // discover any further splits
+        bphi.setType(TypeMem.BOT);
+        Node bulk = bphi;
+        IterPeeps.add(bulk);
+        IterPeeps.add(mem);
+        return aggregate(bulk,alias,mem);
+    }
+
+    // Build aggregate memory over a bulk Phi, preserving every precise slice
+    // which the bulk has already excluded.  The named alias is newly supplied
+    // (or replaces its old slice).
+    MemMergeNode aggregate(Node bulk, int alias, Node precise) {
+        MemMergeNode mmm = new MemMergeNode(bulk);
+        for( int old = _aliases.nextSetBit(0); old >= 0; old = _aliases.nextSetBit(old+1) )
+            { assert old != alias; mmm.alias(old,precisePhi(old));}
+        mmm.alias(alias,precise);
+        assert checkMerge(mmm);
+        return mmm;
+    }
+
+    // Find or make the precise Phi parallel to this bulk Phi at the same merge.
+    private Node precisePhi(int alias) {
+        MemPhiNode mphi = _findPhi(alias);
+        if( mphi!=null ) return mphi;
+
+        mphi = new MemPhiNode("$"+alias,alias);
+        mphi.addDef(region());
+        // Due to cycles, must set before calling peephole
+        mphi.setType(TypeMem.make(alias,Type.BOTTOM));
+        for( int i=1; i<nIns(); i++ )
+            mphi.addDef(IterPeeps.add(preciseInput(in(i),alias)));
+        return IterPeeps.add(mphi);
+    }
+
+    MemPhiNode _findPhi(int alias) {
+        for( Node use : region()._outputs )
+            if( use instanceof MemPhiNode mphi && mphi._alias==alias )
+                return mphi;
+        return null;
+    }
+
+    // Select an alias already split out of a predecessor's bulk memory.
+    private Node preciseInput(Node mem, int alias) {
+        if( mem instanceof MemMergeNode mmm )
+            return mmm.alias(alias);
+        if( mem instanceof BulkMemPhiNode bulk && bulk.isSplit(alias) )
+            return bulk.precisePhi(alias);
+        return mem;
+    }
+
+    // Every alias excluded by a bulk default must be supplied explicitly.
+    static boolean checkMerge(MemMergeNode mmm) {
+        if( !(mmm.in(1) instanceof BulkMemPhiNode bulk) ) return true;
+        for( int alias = bulk._aliases.nextSetBit(0); alias >= 0; alias = bulk._aliases.nextSetBit(alias+1) )
+            if( alias >= mmm.nIns() || mmm.in(alias)==null )
+                return false;
+        return true;
+    }
+
+    @Override public boolean eq(Node n) {
+        return _aliases.equals(((BulkMemPhiNode)n)._aliases) && super.eq(n);
+    }
+
+    @Override int hash() { return _aliases.hashCode(); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/CFGNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/CFGNode.java
new file mode 100644
index 00000000..e85fc6ae
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/CFGNode.java
@@ -0,0 +1,136 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.Utils;
+
+import java.util.BitSet;
+import java.util.HashSet;
+import java.util.HashMap;
+
+/** Control Flow Graph Nodes
+ * <p>
+ *  CFG nodes have a immediate dominator depth (idepth) and a loop nesting
+ *  depth(loop_depth).
+ * <p>
+ *  idepth is computed lazily upon first request, and is valid even in the
+ *  Parser, and is used by peepholes during parsing and afterward.
+ * <p>
+ *  loop_depth is computed after optimization as part of scheduling.
+ *
+ */
+public abstract class CFGNode extends Node {
+
+    public CFGNode(Node... nodes) { super(nodes); }
+
+    public CFGNode cfg(int idx) { return (CFGNode)in(idx); }
+
+    // Block head is Start, Region, CProj, but not e.g. If, Return, Stop
+    public boolean blockHead() { return false; }
+
+    // ------------------------------------------------------------------------
+    /**
+     * Immediate dominator tree depth, used to approximate a real IDOM during
+     * parsing where we do not have the whole program, and also peepholes
+     * change the CFG incrementally.
+     * <p>
+     * See {@link <a href="https://en.wikipedia.org/wiki/Dominator_(graph_theory)">...</a>}
+     */
+    public char _idepth;
+    public int idepth() { return _idepth!=0 ? _idepth : cacheIDepth(idom().idepth()+1); }
+    // Zero depth means uncached. Check before narrowing so overflow cannot wrap.
+    final int cacheIDepth(int depth) {
+        assert 0 <= depth && depth <= Character.MAX_VALUE : "Dominator depth exceeds 65535";
+        return _idepth = (char)depth;
+    }
+
+
+    // Return the immediate dominator of this Node and compute dom tree depth.
+    public CFGNode idom(Node dep) { return cfg(0); }
+    public final CFGNode idom() { return idom(null); }
+
+    // Return the LCA of two idoms
+    public CFGNode domLCA(CFGNode rhs, Node dep) {
+        if( rhs==null ) return this;
+        CFGNode lhs = this;
+        while( lhs != rhs ) {
+            if( lhs==null || rhs==null ) return null;
+            int comp = lhs.idepth() - rhs.idepth();
+            if( comp >= 0 ) lhs = (dep==null ? lhs : (CFGNode)lhs.addDep(dep)).idom();
+            if( comp <= 0 ) rhs = (dep==null ? rhs : (CFGNode)rhs.addDep(dep)).idom();
+        }
+        return lhs;
+    }
+
+    // ------------------------------------------------------------------------
+    // Loop nesting
+    public LoopNode loop() { return _ltree._head; }
+    public int loopDepth() { return _ltree==null ? 0 : _ltree.depth(); }
+
+    LoopTree _ltree;
+    int _pre;                   // Pre-order numbers for loop tree finding
+    private static class LoopTree {
+        LoopTree _par;
+        final LoopNode _head;
+        int _depth;
+        LoopTree(LoopNode head) { _head = head; }
+        @Override public String toString() { return "LOOP"+_head._nid; }
+        int depth() {
+            return _depth==0 ? (_par==null ? 0 : (_depth = _par.depth()+1)) : _depth;
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Tag all CFG Nodes with their containing LoopNode; LoopNodes themselves
+    // also refer to *their* containing LoopNode, as well as have their depth.
+    // Start is a LoopNode which contains all at depth 1.
+    public void buildLoopTree(StopNode stop) {
+        _ltree = stop._ltree = Parser.XCTRL._ltree = new LoopTree((StartNode)this);
+        _bltWalk(2,stop, new BitSet());
+    }
+    private int _bltWalk(int pre, StopNode stop, BitSet post) {
+        // Pre-walked?
+        if( _pre!=0 ) return pre;
+        _pre = pre++;
+        // Pre-walk
+        for( Node use : _outputs )
+            if( use instanceof CFGNode usecfg )
+                pre = usecfg._bltWalk(pre,stop,post);
+
+        // Post-order work: find innermost loop
+        LoopTree inner = null, ltree;
+        for( Node use : _outputs ) {
+            if( !(use instanceof CFGNode usecfg) ) continue;
+            // Child visited but not post-visited?
+            if( !post.get(usecfg._nid) ) {
+                // Must be a backedge to a LoopNode then
+                ltree = usecfg._ltree = new LoopTree((LoopNode)usecfg);
+            } else {
+                // Take child's loop choice, which must exist
+                ltree = usecfg._ltree;
+                // If falling into a loop, use the target loop's parent instead
+                if( ltree._head == usecfg ) {
+                    if( ltree._par == null )
+                        // This loop never had an If test choose to take its
+                        // exit, i.e. it is a no-exit infinite loop.
+                        ltree._par = ltree._head.forceExit(stop)._ltree;
+                    ltree = ltree._par;
+                }
+            }
+            // Sort inner loops.  The decision point is some branch far removed
+            // from either loop head OR either backedge so requires pre-order
+            // numbers to figure out innermost.
+            if( inner == null ) { inner = ltree; continue; }
+            if( inner == ltree ) continue; // No change
+            LoopTree outer = ltree._head._pre > inner._head._pre ? inner : ltree;
+            inner =          ltree._head._pre > inner._head._pre ? ltree : inner;
+            inner._par = outer;
+        }
+        // Set selected loop
+        if( inner!=null )
+            _ltree = inner;
+        // Tag as post-walked
+        post.set(_nid);
+        return pre;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/CProjNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/CProjNode.java
new file mode 100644
index 00000000..53348b5a
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/CProjNode.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMem;
+import com.seaofnodes.simple.type.TypeTuple;
+
+public class CProjNode extends CFGNode {
+
+    // Which slice of the incoming multipart value
+    public final int _idx;
+
+    // Debugging label
+    public final String _label;
+
+    public CProjNode(Node ctrl, int idx, String label) {
+        super(ctrl);
+        _idx = idx;
+        _label = label;
+    }
+
+    @Override public String label() { return _label; }
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p(_label); }
+
+    @Override public boolean isMultiTail() { return in(0).isMultiHead(); }
+    @Override public boolean blockHead() { return true; }
+
+    public CFGNode ctrl() { return cfg(0); }
+
+    @Override
+    public Type compute() {
+        Type t = ctrl()._type;
+        return t instanceof TypeTuple tt ? tt._types[_idx] : Type.BOTTOM;
+    }
+
+    @Override
+    public Node idealize() {
+        if( ctrl()._type instanceof TypeTuple tt ) {
+            if( tt._types[_idx]==Type.XCONTROL )
+                return Parser.XCTRL; // We are dead
+            if( ctrl() instanceof IfNode && tt._types[1-_idx]==Type.XCONTROL ) // Only true for IfNodes
+                return ctrl().in(0);               // We become our input control
+        }
+
+        // Flip a negating if-test, to remove the not
+        if( ctrl() instanceof IfNode iff && iff.pred().addDep(this) instanceof NotNode not )
+            return new CProjNode(new IfNode(iff.ctrl(),not.in(1)).peephole(),1-_idx,_idx==0 ? "False" : "True");
+
+        return null;
+    }
+
+    @Override
+    boolean eq( Node n ) { return _idx == ((CProjNode)n)._idx; }
+
+    @Override
+    int hash() { return _idx; }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/CastNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/CastNode.java
new file mode 100644
index 00000000..9ade5a50
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/CastNode.java
@@ -0,0 +1,37 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.IterPeeps;
+
+
+// Upcast (join) the input to a t.  Used after guard test to lift an input.
+// Can also be used to make a type-assertion if ctrl is null.
+public class CastNode extends Node {
+    private final Type _t;
+    public CastNode(Type t, Node ctrl, Node in) {
+        super(ctrl, in);
+        _t = t;
+        setType(compute());
+    }
+
+    @Override public String label() { return "("+_t.str()+")"; }
+
+
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.p(label()).n(in(1));
+    }
+
+    @Override
+    public Type compute() {
+        return in(1)._type.join(_t);
+    }
+
+    @Override
+    public Node idealize() {
+        return in(1)._type.isa(_t) ? in(1) : null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ConstantNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
new file mode 100644
index 00000000..426736ed
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
@@ -0,0 +1,56 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.Type;
+
+
+/**
+ * A Constant node represents a constant value.  At present, the only constants
+ * that we allow are integer literals; therefore Constants contain an integer
+ * value.  As we add other types of constants, we will refactor how we represent
+ * Constants.
+ * <p>
+ * Constants have no semantic inputs. However, we set Start as an input to
+ * Constants to enable a forward graph walk.  This edge carries no semantic
+ * meaning, and it is present <em>solely</em> to allow visitation.
+ * <p>
+ * The Constant's value is the value stored in it.
+ */
+public class ConstantNode extends Node {
+    final Type _con;
+    public ConstantNode( Type type ) {
+        super(Parser.START);
+        _con = type;
+    }
+
+    @Override protected String repeatName() {
+        return _con==null || _con.toString().length()<=32 ? null : uniqueName();
+    }
+
+    @Override
+    public String label() { return "Con"; }
+
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.p(_con);
+    }
+
+    @Override public boolean isMultiTail() { return true; }
+
+    @Override
+    public Type compute() { return _con; }
+
+    @Override
+    public Node idealize() { return null; }
+
+    @Override
+    boolean eq(Node n) {
+        ConstantNode con = (ConstantNode)n; // Contract
+        return _con==con._con;
+    }
+
+    @Override
+    int hash() { return _con.hashCode(); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/DivFNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/DivFNode.java
new file mode 100644
index 00000000..c678ac3e
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/DivFNode.java
@@ -0,0 +1,39 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+
+
+public class DivFNode extends Node {
+    public DivFNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "DivF"; }
+
+    @Override protected String format() { return "(%1/%2)"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeFloat i0 &&
+            in(2)._type instanceof TypeFloat i1) {
+            if (i0.isConstant() && i1.isConstant())
+                return TypeFloat.constant(i0.value()/i1.value());
+        }
+        return in(1)._type.meet(in(2)._type);
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // Div of 1.
+        if ( t2.isConstant() && t2 instanceof TypeFloat i && i.value()==1 )
+            return lhs;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new DivFNode(lhs,rhs); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/DivNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/DivNode.java
new file mode 100644
index 00000000..cd749a03
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/DivNode.java
@@ -0,0 +1,40 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class DivNode extends Node {
+    public DivNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Div"; }
+
+    @Override protected String format() { return "(%1/%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i1 &&
+            t2 instanceof TypeInteger i2 ) {
+            if (i1.isConstant() && i2.isConstant())
+                return i2.value() == 0
+                    ? TypeInteger.ZERO
+                    : TypeInteger.constant(i1.value()/i2.value());
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        // Div of 1.
+        if( in(2)._type == TypeInteger.TRUE )
+            return in(1);
+        return null;
+    }
+
+    @Override Node copy(Node lhs, Node rhs) { return new DivNode(lhs,rhs); }
+    @Override Node copyF() { return new DivFNode(null,null); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/IfNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/IfNode.java
new file mode 100644
index 00000000..2b53b3a3
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/IfNode.java
@@ -0,0 +1,62 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeTuple;
+import java.util.HashSet;
+
+public class IfNode extends CFGNode implements MultiNode {
+
+    public IfNode(Node ctrl, Node pred) {
+        super(ctrl, pred);
+        IterPeeps.add(this);    // Because idoms are complex, just add it
+    }
+
+    @Override
+    public String label() { return "If"; }
+
+    @Override protected String format() { return "if( %1 )"; }
+
+    @Override public boolean isMultiHead() { return true; }
+
+    public Node ctrl() { return in(0); }
+    public Node pred() { return in(1); }
+
+    @Override
+    public Type compute() {
+        // If the If node is not reachable then neither is any following Proj
+        if (ctrl()._type != Type.CONTROL && ctrl()._type != Type.BOTTOM )
+            return TypeTuple.IF_NEITHER;
+        Node pred = pred();
+        Type t = pred._type;
+        // High types mean NEITHER side is reachable.
+        // Wait until the type falls to decide which way to go.
+        if( t == Type.TOP || t == TypeInteger.TOP )
+            return TypeTuple.IF_NEITHER;
+        // If constant is 0 then false branch is reachable
+        // Else true branch is reachable
+        if( t.isConstant() )
+            return t.makeInit()==t ? TypeTuple.IF_FALSE : TypeTuple.IF_TRUE;
+        // Integers allow non-zero ranges: "1-65535"
+        if( t.makeZero().meet(t) != t )
+            return TypeTuple.IF_TRUE;
+
+        return TypeTuple.IF_BOTH;
+    }
+
+    @Override
+    public Node idealize() {
+        // Hunt up the immediate dominator tree.  If we find an identical if
+        // test on either the true or false branch, that side wins.
+        if( !pred()._type.isHighOrConst() )
+            for( CFGNode dom = idom(), prior=this; dom!=null;  prior = dom, dom = dom.idom() )
+                if( dom.addDep(this) instanceof IfNode iff && iff.pred().addDep(this)==pred() && prior instanceof CProjNode prj ) {
+                    setDef(1,new ConstantNode(TypeInteger.make(true,prj._idx==0?1:0)).peephole());
+                    return this;
+                }
+        return null;
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/LoadNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/LoadNode.java
new file mode 100644
index 00000000..85ad243b
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/LoadNode.java
@@ -0,0 +1,222 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.type.*;
+import java.util.BitSet;
+import java.util.ArrayList;
+
+/**
+ * Load represents extracting a value from inside a memory object,
+ * in chapter 10 this means Struct fields.
+ */
+public class LoadNode extends MemOpNode {
+
+    /**
+     * Load a value from a ptr.field.
+     *
+     * @param name  The field we are loading
+     * @param mem   The memory alias node - this is updated after a Store
+     * @param ptr   The ptr to the struct base from where we load a field
+     * @param off   The offset inside the struct base
+     */
+    public LoadNode(String name, int alias, Type glb, Node mem, Node ptr, Node off) {
+        super(name, alias, glb, mem, ptr, off);
+    }
+
+    @Override boolean canDrop(MemOpNode other, Node dep) {
+        return super.canDrop(other,dep) && !clobbered(dep);
+    }
+
+    // Check only immediate memory users. Stores clobber memory; Phis and
+    // aggregates might lead to a clobber, so stop rather than search further.
+    private boolean clobbered(Node dep) {
+        Node mem = mem();
+        mem.addDepForwards(dep);
+        for( Node use : mem._outputs ) {
+            if( use==null ) continue;
+            use.addDepForwards(dep);
+            if( use instanceof StoreNode || use instanceof PhiNode ||
+                use instanceof MemMergeNode ||
+                use instanceof NewNode ) return true;
+        }
+        return false;
+    }
+
+    // Debugger label
+    @Override public String  label() { return "ld_"+mlabel(); }
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p(".").p(_name); }
+
+    @Override
+    public Type compute() {
+        Type t = MemMergeNode.contents(mem(),_alias,this);
+        // Update declared forward ref to the actual.
+        if( _declaredType.isFRef() && t instanceof TypeMemPtr tmp && !tmp.isFRef() )
+            _declaredType = tmp.withAccess(((TypeMemPtr)_declaredType)._ro);
+        Type rez = err()==null ? _declaredType.join(t) : _declaredType;
+        return ptr()._type.isFinal() || _declaredType.isFinal() ? rez.makeRO() : rez;
+    }
+
+    @Override
+    public Node idealize() {
+        if( mem() instanceof MemMergeNode merge ) {
+            setDef(1,IterPeeps.add(merge.alias(_alias)));
+            return this;
+        }
+        Node ptr = ptr();
+
+        // Simple Load-after-Store on same address.
+        if( mem() instanceof StoreNode st &&
+            _alias==st._alias && ptr == st.ptr() && off() == st.off() ) { // Must check same object
+            assert _name.equals(st._name); // Equiv class aliasing is perfect
+            return castRO(st.val());
+        }
+
+        // Simple Load-after-New on same address.
+        if( mem() instanceof ProjNode p && p.in(0) instanceof NewNode nnn &&
+            ptr == nnn.proj(0) ) // Must check same object
+            return castRO(nnn.in(nnn.findAlias(_alias))); // Load from New init
+
+        // Load-after-Store on same address, but bypassing provably unrelated
+        // stores.  This is a more complex superset of the above two peeps.
+        // "Provably unrelated" is really weak.
+        if( ptr instanceof ReadOnlyNode ro )
+            ptr = ro.in(1);
+        Node mem = mem();
+        outer:
+        while( true ) {
+            mem.addDep(this);
+            switch( mem ) {
+            case MemMergeNode merge:
+                mem = merge.alias(_alias);
+                break;
+            case StoreNode st:
+                if( _alias==st._alias && ptr == st.ptr() && off() == st.off() )
+                    return castRO(st.val()); // Proved equal
+                // Can we prove unequal?  Offsets do not overlap?
+                if( _alias==st._alias && !off()._type.join(st.off()._type).isHigh() && // Offsets overlap
+                    !neverAlias(ptr,st.ptr()) )                   // And might alias
+                    break outer; // Cannot tell, stop trying
+                // Pointers cannot overlap
+                mem = st.mem(); // Proved never equal
+                break;
+            case PhiNode phi:      break outer;  // Assume related
+            case ConstantNode top: break outer;  // Assume shortly dead
+            case ProjNode mproj:
+                if( mproj.in(0) instanceof NewNode nnn1 ) {
+                    if( ptr instanceof ProjNode pproj && pproj.in(0) == mproj.in(0) )
+                        return castRO(nnn1.in(nnn1.findAlias(_alias))); // Load from New init
+                    if( !(ptr instanceof ProjNode pproj && pproj.in(0) instanceof NewNode nnn2) )
+                        break outer; // Cannot tell, ptr not related to New
+                    mem = nnn1.mem();// Bypass unrelated New
+                    break;
+                } else break outer;
+            default:
+                break outer;
+            }
+        }
+
+        // Push a Load up through a Phi, as long as it collapses on at least
+        // one arm.  If at a Loop, the backedge MUST collapse - else we risk
+        // spinning the same transform around the loop indefinitely.
+        //   BEFORE (2 Sts, 1 Ld):          AFTER (1 St, 0 Ld):
+        //   if( pred ) ptr.x = e0;         val = pred ? e0
+        //   else       ptr.x = e1;                    : e1;
+        //   val = ptr.x;                   ptr.x = val;
+        if( mem() instanceof MemPhiNode memphi && memphi.region()._type == Type.CONTROL && memphi.nIns()== 3 &&
+            // Offset can be hoisted
+            off() instanceof ConstantNode &&
+            // Pointer can be hoisted
+            hoistPtr(ptr,memphi)  ) {
+
+            // Profit on RHS/Loop backedge
+            if( profit(memphi,2) ||
+                // Else must not be a loop to count profit on LHS.
+                (!(memphi.region() instanceof LoopNode) && profit(memphi,1)) ) {
+                Node ld1 = ld(1);
+                Node ld2 = ld(2);
+                return new PhiNode(_name,_declaredType,memphi.region(),ld1,ld2);
+            }
+        }
+
+        return null;
+    }
+
+    private Node ld( int idx ) {
+        Node mem = mem(), ptr = ptr();
+        LoadNode ld = new LoadNode(_name,_alias,_declaredType,mem.in(idx),ptr instanceof PhiNode && ptr.in(0)==mem.in(0) ? ptr.in(idx) : ptr,off());
+        ld.setDef(0,in(0));
+        return ld.peephole();
+    }
+
+    private static boolean neverAlias( Node ptr1, Node ptr2 ) {
+        return ptr1.in(0) != ptr2.in(0) &&
+            // Unrelated allocations
+            ptr1 instanceof ProjNode && ptr1.in(0) instanceof NewNode &&
+            ptr2 instanceof ProjNode && ptr2.in(0) instanceof NewNode;
+    }
+
+    private static boolean hoistPtr(Node ptr, PhiNode memphi ) {
+        // Can I hoist ptr above the Region?
+        if( !(memphi.region() instanceof RegionNode r) )
+            return false;       // Dead or dying Region/Phi
+        // If ptr from same Region, then yes, just use hoisted split pointers
+        if( ptr instanceof PhiNode pphi && pphi.region() == r )
+            return true;
+
+        // No, so can we lift this ptr?
+        CFGNode cptr = ptr.cfg0();
+        if( cptr != null )
+            // Pointer is controlled high
+            // TODO: Really needs to be the LCA of all inputs is high
+            return cptr.idepth() <= r.idepth();
+
+        // Dunno without a longer walk
+        return false;
+    }
+
+    // Profitable if we find a matching Store on this Phi arm.
+    private boolean profit(PhiNode phi, int idx) {
+        Node px = phi.in(idx);
+        if( px==null ) return false;
+        px.addDep(this);
+        if( px._type instanceof TypeMem mem && mem._t.isHighOrConst() ) return true;
+        if( px instanceof StoreNode st1 && _alias==st1._alias && ptr()==st1.ptr() && off()==st1.off() ) return true;
+        return false;
+    }
+
+    // Read-Only is a deep property, and cannot be cast-away
+    private Node castRO(Node rez) {
+        if( (ptr()._type.isFinal() || _declaredType.isFinal()) && !rez._type.isFinal() )
+            return new ReadOnlyNode(rez).peephole();
+        return rez;
+    }
+
+    // Memory writers which must follow this read. A packaging node is not a
+    // write, but can hide New's input, so follow this alias through aggregates.
+    public ArrayList<Node> antiDeps() {
+        ArrayList<Node> deps = new ArrayList<>();
+        antiDeps(mem(),deps,new BitSet());
+        return deps;
+    }
+
+    private void antiDeps(Node mem, ArrayList<Node> deps, BitSet visit) {
+        if( visit.get(mem._nid) ) return;
+        visit.set(mem._nid);
+        for( Node use : mem._outputs ) {
+            if( use instanceof MemMergeNode merge ) {
+                Node slice = _alias<merge.nIns() ? merge.in(_alias) : null;
+                if( (slice==mem) || (slice==null && merge.in(1)==mem) )
+                    antiDeps(merge,deps,visit);
+            } else if( (use instanceof StoreNode st && st._alias==_alias) ||
+                       (use instanceof NewNode nnn && nnn.field(_alias)!=null) ||
+                       (use instanceof MemPhiNode phi && phi._alias==_alias) ||
+                       (use instanceof BulkMemPhiNode phi && !phi.isSplit(_alias)) ) {
+                if( !deps.contains(use) ) deps.add(use);
+            }
+        }
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/LoopNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/LoopNode.java
new file mode 100644
index 00000000..8fb6a4ce
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/LoopNode.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+import java.util.BitSet;
+import java.util.HashSet;
+
+public class LoopNode extends RegionNode {
+    public LoopNode( Node entry ) { super(null,entry,null); }
+
+    public CFGNode entry() { return cfg(1); }
+    public CFGNode back () { return cfg(2); }
+
+    @Override
+    public String label() { return "Loop"; }
+
+    @Override
+    public Type compute() {
+        if( inProgress() ) return Type.CONTROL;
+        return entry()._type;
+    }
+
+    @Override
+    public Node idealize() {
+        return inProgress() ? null : super.idealize();
+    }
+
+    // Bypass Region idom, same as the default idom() using use in(1) instead of in(0)
+    @Override public int idepth() { return _idepth!=0 ? _idepth : cacheIDepth(entry().idepth()+1); }
+    // Bypass Region idom, same as the default idom() using use in(1) instead of in(0)
+    @Override public CFGNode idom(Node dep) { return entry(); }
+
+    // If this is an unreachable loop, it may not have an exit.  If it does not
+    // (i.e., infinite loop), force an exit to make it reachable.
+    public StopNode forceExit( StopNode stop ) {
+        // Walk the backedge, then immediate dominator tree util we hit this
+        // Loop again.  If we ever hit a CProj from an If (as opposed to
+        // directly on the If) we found our exit.
+        CFGNode x = back();
+        while( x != this ) {
+            if( x instanceof CProjNode exit && exit.in(0) instanceof IfNode iff ) {
+                CFGNode other = iff.cproj(1-exit._idx);
+                if( other.loopDepth() < loopDepth() )
+                    return stop; // Found an exit, not an infinite loop
+            }
+            x = x.idom();
+        }
+        // Found a no-exit loop.  Insert an exit
+        NeverNode iff = new NeverNode(back());
+        for( Node use : _outputs )
+            if( use instanceof PhiNode phi )
+                iff.addDef(use);
+        CProjNode t = new CProjNode(iff,0,"True" );
+        CProjNode f = new CProjNode(iff,1,"False");
+        setDef(2,f);
+        stop.addDef(new ReturnNode(t,Parser.ZERO,null));
+        return stop;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java
new file mode 100644
index 00000000..faf456de
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java
@@ -0,0 +1,90 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMem;
+
+/** A default slice and explicit alias overrides. A null default means partial
+ *  memory: absent aliases are not covered, rather than having unknown contents.
+ */
+public class MemMergeNode extends Node {
+    public MemMergeNode(Node bulk) { super(null,bulk); _type = TypeMem.BOT; }
+    public MemMergeNode(Node bulk, int alias, Node precise) {
+        this(bulk);
+        alias(alias,precise);
+    }
+
+    public Node alias(int alias) {
+        Node n = alias < nIns() ? in(alias) : null;
+        assert n!=null || !(in(1) instanceof BulkMemPhiNode bulk) || !bulk.isSplit(alias);
+        n = n==null ? in(1) : n;
+        assert n!=null : "Alias not covered: "+alias;
+        return n;
+    }
+
+    public void alias(int alias, Node mem) {
+        assert alias > 1;
+        while( nIns()<=alias ) addDef(null);
+        setDef(alias,mem);
+    }
+
+    // Scalar contents of one alias. New's field inputs supply the initialized type;
+    // join it with the incoming contents for all previously allocated objects.
+    // Phis use their cached types, so this query does not recurse around loops.
+    static Type contents(Node mem, int alias, Node dep) {
+        mem.addDep(dep);
+        if( mem instanceof MemMergeNode merge )
+            return contents(merge.alias(alias),alias,dep);
+        if( mem instanceof ProjNode proj && proj.in(0) instanceof NewNode nnn ) {
+            assert proj._idx==1 && nnn.field(alias)!=null;
+            nnn.addDep(dep);
+            Node init = nnn.in(nnn.findAlias(alias)).addDep(dep);
+            return contents(nnn.mem(),alias,dep).meet(init._type);
+        }
+        // There are no heap arguments in this chapter. Before the first New,
+        // the set of allocated objects (and hence stored values) is empty.
+        if( mem instanceof ProjNode proj && proj.in(0) instanceof StartNode ) return Type.TOP;
+        if( mem._type==Type.TOP || mem._type==TypeMem.TOP ) return Type.TOP;
+        if( mem._type instanceof TypeMem mt && mt._alias==alias ) return mt._t;
+        return Type.BOTTOM;
+    }
+
+    @Override public String label() { return "MemMerge"; }
+    @Override public boolean isMem() { return true; }
+    @Override public Type compute() { return TypeMem.BOT; }
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        p.p("MEM[");
+        for( int i=1; i<nIns(); i++ )
+            if( in(i)!=null ) {
+                p.p(i==1 ? "default:" : i+":");
+                p.n(in(i)).p(" ");
+            }
+        return p.p("]");
+    }
+
+    @Override public Node idealize() {
+        boolean progress=false, allDefault=true;
+        for( int i=2; i<nIns(); i++ ) {
+            if( in(i)!=null && in(i)==in(1) ) { setDef(i,null); progress=true; }
+            if( in(i) instanceof MemMergeNode mem ) {
+                setDef(i,IterPeeps.add(mem.alias(i)));
+                progress=true;
+            }
+            if( in(i)!=null ) allDefault=false;
+        }
+        if( allDefault && in(1)!=null ) return in(1);
+
+        if( in(1) instanceof MemMergeNode mem ) {
+            for( int i=2; i<mem.nIns(); i++ )
+                if( mem.in(i)!=null && (i>=nIns() || in(i)==null) )
+                    alias(i,mem.in(i));
+            IterPeeps.add(mem.in(1));
+            setDef(1,mem.in(1));
+            return this;
+        }
+        assert BulkMemPhiNode.checkMerge(this);
+        return progress ? this : null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MemOpNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MemOpNode.java
new file mode 100644
index 00000000..0bf9b6ac
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MemOpNode.java
@@ -0,0 +1,62 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMemPtr;
+
+/**
+ * Convenience common base for Load and Store.
+ */
+public abstract class MemOpNode extends Node {
+
+    public final String _name;
+    public final int _alias;
+    // Declared type; not final because it might be a forward-reference
+    // which will be lazily improved when the reference is declared.
+    public Type _declaredType;
+
+    public MemOpNode(String name, int alias, Type glb, Node mem, Node ptr, Node off) {
+        super(null, mem, ptr, off);
+        _name  = name;
+        _alias = alias;
+        _declaredType = glb;
+    }
+    public MemOpNode(String name, int alias, Type glb, Node mem, Node ptr, Node off, Node value) {
+        this(name, alias, glb, mem, ptr, off);
+        addDef(value);
+    }
+
+    //
+    static String mlabel(String name) { return name.equals("[]") ? "ary" : (name.equals("#") ? "len" : name); }
+    String mlabel() { return mlabel(_name); }
+
+    public Node mem() { return in(1); }
+    public Node ptr() { return in(2); }
+    public Node off() { return in(3); }
+
+    // Extra conditions for factoring matching memory operations through a Phi.
+    // The caller has already checked the opcode, input shape and control.
+    boolean canDrop(MemOpNode other, Node dep) {
+        ptr().addDep(dep);
+        return _alias==other._alias && _declaredType==other._declaredType && err()==null;
+    }
+
+    @Override
+    boolean eq(Node n) {
+        MemOpNode mem = (MemOpNode)n; // Invariant
+        return _alias==mem._alias;    // When comparing types error to use "equals"; always use "=="
+    }
+
+    @Override
+    int hash() { return _alias; }
+
+    @Override
+    String err() {
+        Type ptr = ptr()._type;
+        // Already an error, but better error messages come from elsewhere
+        if( ptr == Type.BOTTOM ) return null;
+        // Better be a not-nil TMP
+        if( ptr instanceof TypeMemPtr tmp && !tmp._nil )
+            return null;
+        return "Might be null accessing '" + _name + "'";
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MemPhiNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MemPhiNode.java
new file mode 100644
index 00000000..6aae00f9
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MemPhiNode.java
@@ -0,0 +1,42 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMem;
+
+/** A Phi for one field alias, parallel to a bulk Phi at the same Region. */
+public class MemPhiNode extends PhiNode {
+    public final int _alias;
+
+    public MemPhiNode(String label, int alias, Node... inputs) {
+        super(label,TypeMem.make(alias,Type.BOTTOM),inputs);
+        assert alias > 1;
+        _alias = alias;
+    }
+
+    @Override public String label() { return "MemPhi_"+_alias; }
+
+    @Override public Type compute() {
+        assert BulkMemPhiNode.checkMem(this,_alias);
+        if( !(region() instanceof RegionNode r) )
+            return region()._type==Type.XCONTROL ? TypeMem.TOP : _type;
+        if( r.inProgress() ) return _declaredType;
+        Type t = Type.TOP;
+        for( int i=1; i<nIns(); i++ )
+            if( r.in(i).addDep(this)._type!=Type.XCONTROL )
+                t = t.meet(MemMergeNode.contents(in(i),_alias,this));
+        return TypeMem.make(_alias,t);
+    }
+
+    @Override public Node idealize() {
+        for( int i=1; i<nIns(); i++ )
+            if( in(i) instanceof MemMergeNode mem ) {
+                setDef(i,IterPeeps.add(mem.alias(_alias)));
+                return this;
+            }
+        return super.idealize();
+    }
+
+    @Override boolean eq(Node n) { return _alias==((MemPhiNode)n)._alias && super.eq(n); }
+    @Override int hash() { return _alias; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MinusFNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MinusFNode.java
new file mode 100644
index 00000000..1b45c7c5
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MinusFNode.java
@@ -0,0 +1,30 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+
+
+public class MinusFNode extends Node {
+    public MinusFNode(Node in) { super(null, in); }
+
+    @Override public String label() { return "MinusF"; }
+
+    @Override protected String format() { return "(-%1)"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeFloat i0)
+            return i0.isConstant() ? TypeFloat.constant(-i0.value()) : i0;
+        return TypeFloat.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        // -(-x) is x
+        if( in(1) instanceof MinusFNode minus )
+            return minus.in(1);
+
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MinusNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MinusNode.java
new file mode 100644
index 00000000..b85af74e
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MinusNode.java
@@ -0,0 +1,36 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.Utils;
+
+
+public class MinusNode extends Node {
+    public MinusNode(Node in) { super(null, in); }
+
+    @Override public String label() { return "Minus"; }
+
+    @Override protected String format() { return "(-%1)"; }
+
+    @Override
+    public Type compute() {
+        if( in(1)._type instanceof TypeInteger i0 ) {
+            if( i0.isHigh() ) return TypeInteger.TOP;
+            if( i0==TypeInteger.BOT || i0._min == Long.MIN_VALUE || i0._max == Long.MIN_VALUE )
+                return TypeInteger.BOT;
+            return TypeInteger.make(-i0._max,-i0._min);
+        }
+        return in(1)._type.isHigh() ? TypeInteger.TOP : TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        // -(-x) is x
+        if( in(1) instanceof MinusNode minus )
+            return minus.in(1);
+
+        return null;
+    }
+    @Override Node copyF() { return new MinusFNode(null); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MulFNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MulFNode.java
new file mode 100644
index 00000000..6a57f3c5
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MulFNode.java
@@ -0,0 +1,44 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+
+
+public class MulFNode extends Node {
+    public MulFNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "MulF"; }
+
+    @Override protected String format() { return "(%1*%2)"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeFloat i0 &&
+            in(2)._type instanceof TypeFloat i1) {
+            if (i0.isConstant() && i1.isConstant())
+                return TypeFloat.constant(i0.value()*i1.value());
+        }
+        return in(1)._type.meet(in(2)._type);
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // Mul of 1.  We do not check for (1*x) because this will already
+        // canonicalize to (x*1)
+        if ( t2.isConstant() && t2 instanceof TypeFloat i && i.value()==1 )
+            return lhs;
+
+        // Move constants to RHS: con*arg becomes arg*con
+        if ( t1.isConstant() && !t2.isConstant() )
+            return swap12();
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new MulFNode(lhs,rhs); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MulNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MulNode.java
new file mode 100644
index 00000000..a9ac07e6
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MulNode.java
@@ -0,0 +1,61 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class MulNode extends Node {
+    public MulNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Mul"; }
+
+    @Override protected String format() { return "(%1*%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i1 &&
+            t2 instanceof TypeInteger i2 ) {
+            if( i1==TypeInteger.ZERO || i2==TypeInteger.ZERO)
+                return TypeInteger.ZERO;
+            if (i1.isConstant() && i2.isConstant())
+                return TypeInteger.constant(i1.value()*i2.value());
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // Mul of 1.  We do not check for (1*x) because this will already
+        // canonicalize to (x*1)
+        if ( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==1 )
+            return lhs;
+
+        // Move constants to RHS: con*arg becomes arg*con
+        if ( t1.isConstant() && !t2.isConstant() )
+            return swap12();
+
+        // Do we have ((x * (phi cons)) * con) ?
+        // Do we have ((x * (phi cons)) * (phi cons)) ?
+        // Push constant up through the phi: x * (phi con0*con0 con1*con1...)
+        Node phicon = AddNode.phiCon(this,true);
+        if( phicon!=null ) return phicon;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new MulNode(lhs,rhs); }
+    @Override Node copyF() { return new MulFNode(null,null); }
+    @Override public String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '"+label()+"' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '"+label()+"' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/MultiNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/MultiNode.java
new file mode 100644
index 00000000..ac9c0045
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/MultiNode.java
@@ -0,0 +1,20 @@
+package com.seaofnodes.simple.node;
+
+public interface MultiNode extends OutNode {
+
+    // Find a projection by index
+    default ProjNode proj( int idx ) {
+        for( Node out : outs() )
+            if( out instanceof ProjNode prj && prj._idx==idx )
+                return prj;
+        return null;
+    }
+
+    // Find a projection by index
+    default CProjNode cproj( int idx ) {
+        for( Node out : outs() )
+            if( out instanceof CProjNode prj && prj._idx==idx )
+                return prj;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/NeverNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/NeverNode.java
new file mode 100644
index 00000000..7e42ccf9
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/NeverNode.java
@@ -0,0 +1,22 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeTuple;
+
+
+// "Never true" for infinite loop exits
+public class NeverNode extends IfNode {
+    public NeverNode(Node ctrl) { super(ctrl,Parser.ZERO); }
+
+    @Override public String label() { return "Never"; }
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p("Never"); }
+
+    @Override public Type compute() { return TypeTuple.IF_BOTH; }
+
+    @Override public Node idealize() { return null; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/NewNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/NewNode.java
new file mode 100644
index 00000000..51341c41
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/NewNode.java
@@ -0,0 +1,60 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.*;
+
+/** Allocate and initialize an object. Inputs {ctrl, $mem, size, fields...};
+ *  results {ptr, $mem}.
+ *  The memory input and result cover only the aliases in the allocated struct.
+ */
+public class NewNode extends Node implements MultiNode {
+
+    public final TypeMemPtr _ptr;
+
+    public NewNode(TypeMemPtr ptr, Node... nodes) {
+        super(nodes);
+        _ptr = ptr;
+        assert nodes.length==3+ptr._obj._fields.length;
+        assert nodes[0]._type==Type.CONTROL || nodes[0]._type==Type.XCONTROL;
+        assert nodes[1]._type instanceof TypeMem;
+        assert nodes[2]._type instanceof TypeInteger;
+        for( int i=3; i<nodes.length; i++ ) assert nodes[i]._type!=null;
+    }
+
+    public Node mem() { return in(1); }
+    public Node size() { return in(2); }
+
+    public Field field(int alias) {
+        for( Field f : _ptr._obj._fields )
+            if( f._alias==alias ) return f;
+        return null;
+    }
+
+    @Override public String label() {
+        return "new_"+(_ptr._obj.isAry() ? "ary_"+_ptr._obj._fields[1]._type.str() : _ptr._obj.str());
+    }
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.p("new ").p(_ptr._obj.str());
+    }
+
+    // Find matching alias input
+    int findAlias(int alias) {
+        return 3+_ptr._obj.findAlias(alias);
+    }
+
+
+    @Override
+    public TypeTuple compute() {
+        return TypeTuple.make(_ptr,TypeMem.BOT);
+    }
+
+    @Override
+    public Node idealize() { return null; }
+
+    @Override
+    boolean eq(Node n) { return this == n; }
+
+    @Override
+    int hash() { return _ptr.hashCode(); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/Node.java
new file mode 100644
index 00000000..e70fe495
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -0,0 +1,610 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.BaseNode;
+
+import com.seaofnodes.simple.Parser;
+
+import com.seaofnodes.simple.Ary;
+import com.seaofnodes.simple.IRPrinter;
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+import java.util.*;
+import java.util.function.Function;
+
+/**
+ * All Nodes in the Sea of Nodes IR inherit from the Node class.
+ * The Node class provides common functionality used by all subtypes.
+ * Subtypes of Node specialize by overriding methods.
+ */
+public abstract class Node extends BaseNode<Node> implements OutNode, Cloneable {
+
+    /**
+     * Inputs to the node. These are use-def references to Nodes.
+     * <p>
+     * Generally fixed length, ordered, nulls allowed, no unused trailing space.
+     * Ordering is required because e.g. "a/b" is different from "b/a".
+     * The first input (offset 0) is often a {@link CFGNode} node.
+     */
+    public Ary<Node> _inputs;
+
+    /**
+     * Outputs reference Nodes that are not null and have this Node as an
+     * input.  These nodes are users of this node, thus these are def-use
+     * references to Nodes.
+     * <p>
+     * Outputs directly match inputs, making a directed graph that can be
+     * walked in either direction.  These outputs are typically used for
+     * efficient optimizations but otherwise have no semantics meaning.
+     */
+    public Ary<Node> _outputs;
+
+    /**
+     * Current computed type for this Node.  This value changes as the graph
+     * changes and more knowledge is gained about the program.
+     */
+    public Type _type;
+
+    /**
+     * A private Global Static mutable counter, for unique node id generation.
+     * To make the compiler multithreaded, this field will have to move into a TLS.
+     * Starting with value 1, to avoid bugs confusing node ID 0 with uninitialized values.
+     * */
+    private static int UNIQUE_ID = 1;
+    public static int UID() { return UNIQUE_ID; }
+
+    protected Node(Node... inputs) {
+        super(UNIQUE_ID++); // allocate unique dense ID
+        _inputs = new Ary<>(Node.class);
+        Collections.addAll(_inputs,inputs);
+        _outputs = new Ary<>(Node.class);
+        for( Node n : _inputs )
+            if( n != null )
+                n.addUse( this );
+    }
+
+    // Easy reading label for debugger, e.g. "Add" or "Region" or "EQ"
+    public abstract String label();
+
+    public String p(int depth) { return IRPrinter.prettyPrint(this,depth); }
+
+    public boolean isMultiHead() { return false; }
+    public boolean isMultiTail() { return false; }
+
+    // ------------------------------------------------------------------------
+    // Graph Node & Edge manipulation
+
+    @Override public String typeName() { return _type==null ? null : _type.toString(); }
+
+    /**
+     * Gets the ith input node
+     * @param i Offset of the input node
+     * @return Input node or null
+     */
+    public Node in(int i) { return _inputs.get(i); }
+    public Node out(int i) { return _outputs.get(i); }
+    @Override public Ary<Node> outs() { return _outputs; }
+
+    public int nIns() { return _inputs.size(); }
+
+    public int nOuts() { return _outputs.size(); }
+
+    public boolean isUnused() { return nOuts() == 0; }
+
+    public CFGNode cfg0() { return (CFGNode)in(0); }
+
+    /**
+     * Change a <em>def</em> into a Node.  Keeps the edges correct, by removing
+     * the corresponding <em>use->def</em> edge.  This may make the original
+     * <em>def</em> go dead.  This function is co-recursive with {@link #kill}.
+     * <p>
+
+     * This method is the normal path for altering a Node, because it does the
+     * proper default edge maintenance.  It also <em>immediately</em> kills
+     * Nodes that lose their last use; at times care must be taken to avoid
+     * killing Nodes that are being used without having an output Node.  This
+     * definitely happens in the middle of recursive {@link #peephole} calls.
+     *
+     * @param idx which def to set
+     * @param new_def the new definition
+     * @return new_def for flow coding
+     */
+    public <N extends Node> N setDef(int idx, N new_def ) {
+        unlock();
+        Node old_def = in(idx);
+        if( old_def == new_def ) return new_def; // No change
+        // If new def is not null, add the corresponding def->use edge
+        // This needs to happen before removing the old node's def->use edge as
+        // the new_def might get killed if the old node kills it recursively.
+        if( new_def != null )
+            new_def.addUse(this);
+        // Set the new_def over the old (killed) edge
+        _inputs.set(idx,new_def);
+        if( old_def != null &&  // If the old def exists, remove a def->use edge
+            old_def.delUse(this) ) // If we removed the last use, the old def is now dead
+            old_def.kill();     // Kill old def
+        moveDepsToWorklist();
+        // Return new_def for easy flow-coding
+        return new_def;
+    }
+
+    // Remove the numbered input, compressing the inputs in-place.  This
+    // shuffles the order deterministically - which is suitable for Region and
+    // Phi, but not for every Node.  If the def goes dead, it is recursively
+    // killed, which may include 'this' Node.
+    Node delDef(int idx) {
+        unlock();
+        Node old_def = in(idx);
+        _inputs.del(idx);
+        if( old_def.delUse(this) ) // If we removed the last use, the old def is now dead
+            old_def.kill();     // Kill old def
+        old_def.moveDepsToWorklist();
+        return this;
+    }
+
+    // Insert the numbered input, sliding other inputs to the right
+    Node insertDef(int idx, Node new_def) {
+        _inputs.add(idx,null);
+        return setDef(idx,new_def);
+    }
+
+    /**
+     * Add a new def to an existing Node.  Keep the edges correct by
+     * adding the corresponding <em>def->use</em> edge.
+     *
+     * @param new_def the new definition, appended to the end of existing definitions
+     * @return new_def for flow coding
+     */
+    public Node addDef(Node new_def) {
+        unlock();
+        // Add use->def edge
+        _inputs.add(new_def);
+        // If new def is not null, add the corresponding def->use edge
+        if( new_def != null )
+            new_def.addUse(this);
+        return new_def;
+    }
+
+    // Breaks the edge invariants, used temporarily
+    protected <N extends Node> void addUse(N n) { _outputs.add(n); }
+
+    // Remove node 'use' from 'def's (i.e. our) output list, by compressing the list in-place.
+    // Return true if the output list is empty afterward.
+    // Error is 'use' does not exist; ok for 'use' to be null.
+    protected boolean delUse( Node use ) {
+        _outputs.del(_outputs.find(use));
+        moveDepsToWorklist(); // User-count and anti-dependence queries can now change.
+        return _outputs.isEmpty();
+    }
+
+    // Shortcut for "popping" until n nodes.  A "pop" is basically a
+    // setDef(last,null) followed by lowering the nIns() count.
+    void popUntil(int n) {
+        unlock();
+        while( nIns() > n ) {
+            Node old_def = _inputs.pop();
+            if( old_def != null &&     // If it exists and
+                old_def.delUse(this) ) // If we removed the last use, the old def is now dead
+                old_def.kill();        // Kill old def
+        }
+    }
+
+    /**
+     * Kill a Node with no <em>uses</em>, by setting all of its <em>defs</em>
+     * to null.  This may recursively kill more Nodes, and is basically dead
+     * code elimination.
+     */
+    public void kill( ) {
+        unlock();
+        moveDepsToWorklist();
+        assert isUnused();      // Has no uses, so it is dead
+        _type=null;             // Flag as dead
+        while( nIns()>0 ) { // Set all inputs to null, recursively killing unused Nodes
+            Node old_def = _inputs.removeLast();
+            if( old_def != null ) {
+                IterPeeps.add(old_def);// Revisit neighbor because removed use
+                if( old_def.delUse(this) ) // If we removed the last use, the old def is now dead
+                    old_def.kill();        // Kill old def
+            }
+        }
+        assert isDead();        // Really dead now
+    }
+
+    // Mostly used for asserts and printing.
+    public boolean isDead() { return isUnused() && nIns()==0 && _type==null; }
+
+    // Shortcuts to stop DCE mid-parse
+    // Add bogus null use to keep node alive
+    public <N extends Node> N keep() { addUse(null); return (N)this; }
+    // Remove bogus null.
+    public <N extends Node> N unkeep() { delUse(null); return (N)this; }
+    // Test "keep" status
+    public boolean iskeep() { return _outputs.find(null) != -1; }
+    public void unkill() {
+        if( unkeep().isUnused() )
+            kill();
+    }
+
+    // Replace self with nnn in the graph, making 'this' go dead
+    public void subsume( Node nnn ) {
+        assert nnn!=this;
+        while( nOuts() > 0 ) {
+            Node n = _outputs.removeLast();
+            n.unlock();
+            int idx = n._inputs.find(this);
+            n._inputs.set(idx,nnn);
+            n.moveDepsToWorklist(); // Rewiring can change a dependent query without changing type.
+            nnn.addUse(n);
+            IterPeeps.addAll(n._outputs);
+        }
+        kill();
+    }
+
+    // ------------------------------------------------------------------------
+    // Graph-based optimizations
+
+    /**
+     * Try to peephole at this node and return a better replacement Node.
+     * Always returns some not-null Node (often this).
+     */
+    public final Node peephole() {
+        var obs = IterPeeps.midAssert() ? null : Parser.PARSER == null ? null : Parser.PARSER._obs;
+        if( obs != null ) obs.before(this);
+        Node n = peepholeOpt();
+        Node rez = n == null ? this : deadCodeElim(n.peephole());
+        if( obs != null ) obs.after(this, n == null ? null : rez, false);
+        return rez;
+    }
+
+    /**
+     * Try to peephole at this node and return a better replacement Node if
+     * possible.  We compute a {@link Type} and then check and replace:
+     * <ul>
+     * <li>if the Type {@link Type#isConstant}, we replace with a {@link ConstantNode}</li>
+     * <li>in a future chapter we will look for a
+     * <a href="https://en.wikipedia.org/wiki/Common_subexpression_elimination">Common Subexpression</a>
+     * to eliminate.</li>
+     * <li>we ask the Node for a better replacement.  The "better replacement"
+     * is things like {@code (1+2)} becomes {@code 3} and {@code (1+(x+2))} becomes
+     * {@code (x+(1+2))}.  By canonicalizing expressions we fold common addressing
+     * math constants, remove algebraic identities and generally simplify the
+     * code. </li>
+     *
+     * Unlike peephole above, this explicitly returns null for no-change, or not-null
+     * for a better replacement (which can be this).
+     * </ul>
+     */
+    public final Node peepholeOpt( ) {
+        ITER_CNT++;
+        // Compute initial or improved Type
+        Type old = setType(compute());
+
+        // Replace constant computations from non-constants with a constant node
+        if( !(this instanceof ConstantNode) && !(this instanceof XCtrlNode) && _type.isHighOrConst() )
+            return (_type==Type.XCONTROL ? new XCtrlNode() : new ConstantNode(_type)).peepholeOpt();
+
+        // Global Value Numbering
+        if( _hash==0 ) {
+            Node n = GVN.get(this); // Will set _hash as a side effect
+            if( n==null )
+                GVN.put(this,this);  // Put in table now
+            else {
+                // Because of random worklist ordering, the two equal nodes
+                // might have different types.  Because of monotonicity, both
+                // types are valid.  To preserve monotonicity, the resulting
+                // shared Node has to have the best of both types.
+                n.setType(n._type.join(_type));
+                _hash = 0; // Clear, since it never went in the table
+                return deadCodeElim(n);// Return previous; does Common Subexpression Elimination
+            }
+        }
+
+        // Ask each node for a better replacement
+        Node n = idealize();
+        if( n != null )         // Something changed
+            return n;           // Report progress
+
+        if( old==_type ) ITER_NOP_CNT++;
+        return old==_type ? null : this; // Report progress
+    }
+    public static int ITER_CNT, ITER_NOP_CNT;
+
+    // m is the new Node, self is the old.
+    // Return 'm', which may have zero uses but is alive nonetheless.
+    // If self has zero uses (and is not 'm'), {@link #kill} self.
+    private Node deadCodeElim(Node m) {
+        // If self is going dead and not being returned here (Nodes returned
+        // from peephole commonly have no uses (yet)), then kill self.
+        if( m != this && isUnused() && !isDead() ) {
+            // Killing self - and since self recursively kills self's inputs we
+            // might end up killing 'm', which we are returning as a live Node.
+            // So we add a bogus extra null output edge to stop kill().
+            m.keep();      // Keep m alive
+            kill();        // Kill self because replacing with 'm'
+            m.unkeep();    // Okay to peephole m
+        }
+        return m;
+    }
+
+    /**
+     * This function needs to be
+     * <a href="https://en.wikipedia.org/wiki/Monotonic_function">Monotonic</a>
+     * as it is part of a Monotone Analysis Framework.
+     * <a href="https://www.cse.psu.edu/~gxt29/teaching/cse597s21/slides/08monotoneFramework.pdf">See for example this set of slides</a>.
+     * <p>
+     * For Chapter 2, all our Types are really integer constants, and so all
+     * the needed properties are trivially true, and we can ignore the high
+     * theory.  Much later on, this will become important and allow us to do
+     * many fancy complex optimizations trivially... because theory.
+     * <p>
+     * {@link #compute()} needs to be stand-alone, and cannot recursively call compute
+     * on its inputs, because programs are cyclic (have loops!) and this will just
+     * infinitely recurse until stack overflow.  Instead, compute typically
+     * computes a new type from the {@link #_type} field of its inputs.
+     */
+    public abstract Type compute();
+
+    // Set the type.  Assert monotonic progress.
+    // If changing, add users to worklist.
+    public Type setType(Type type) {
+        Type old = _type;
+        assert old==null || type.isa(old); // Since _type not set, can just re-run this in assert in the debugger
+        if( old == type ) return old;
+        _type = type;       // Set _type late for easier assert debugging
+        IterPeeps.addAll(_outputs);
+        moveDepsToWorklist();
+        return old;
+    }
+
+    /**
+     * This function rewrites the current Node into a more "idealized" form.
+     * This is the bulk of our peephole rewrite rules, and we use this to
+     * e.g. turn arbitrary collections of adds and multiplies with mixed
+     * constants into a normal form that's easy for hardware to implement.
+     * Example: An array addressing expression:
+     * <pre>   ary[idx+1]</pre>
+     * might turn into Sea-of-Nodes IR:
+     * <pre>   (ary+12)+((idx+1) * 4)</pre>
+     * This expression can then be idealized into:
+     * <pre>   ary + ((idx*4) + (12 + (1*4)))</pre>
+     * And more folding:
+     * <pre>   ary + ((idx<<2) + 16)</pre>
+     * And during code-gen:
+     * <pre>   MOV4 Rary,[Ridx<<2 +16] // or some such hardware-specific notation </pre>
+     * <p>
+     * {@link #idealize} has a very specific calling convention:
+     * <ul>
+     * <li>If NO change is made, return {@code null}
+     * <li>If ANY change is made, return not-null; this can be {@code this}
+     * <li>The returned Node does NOT call {@link #peephole} on itself; the {@link #peephole} call will recursively peephole it.
+     * <li>Any NEW nodes that are not directly returned DO call {@link #peephole}.
+     * </ul>
+     * <p>
+     * Examples:
+     * <table border="3">
+     * <tr><th>    before       </th><th>       after     </th><th>return </th><th>comment  </th></tr>
+     * <tr><td>{@code (x+5)    }</td><td>{@code   (x+5)  }</td><td>{@code null  }</td><td>No change</td></tr>
+     * <tr><td>{@code (5+x)    }</td><td>{@code   (x+5)  }</td><td>{@code this  }</td><td>Swapped arguments</td></tr>
+     * <tr><td>{@code ((x+1)+2)}</td><td>{@code (x+(1+2))}</td><td>{@code (x+_) }</td><td>Returns 2 new Nodes</td></tr>
+     * </table>
+     *
+     * The last entry deserves more discussion.  The new Node {@code (1+2)}
+     * created in {@link #idealize} calls {@link #peephole} (which then folds
+     * into a constant).  The other new Node {@code (x+3)} does not call
+     * peephole, because it is returned and peephole itself will recursively
+     * call peephole.
+     * <p>
+     * Since idealize calls peephole and peephole calls idealize, you must be
+     * careful that all idealizations are <em>monotonic</em>: all transforms
+     * remove some feature, so that the set of available transforms always
+     * shrinks.  If you don't, you risk an infinite peephole loop!
+     *
+     * @return Either a new or changed node, or null for no changes.
+     */
+    public abstract Node idealize();
+
+    // Some of the peephole rules get complex, and search further afield than
+    // just the nearest neighbor.  These peepholes can fail the pattern match
+    // on a node some distance away, and if that node ever changes we should
+    // retry the peephole.  Track a set of Nodes dependent on `this`, and
+    // revisit them if `this` changes.
+    Ary<Node> _deps;
+    public int nDeps() { return _deps == null ? 0 : _deps.size(); }
+    public Node dep(int idx) { return _deps.get(idx); }
+
+    /**
+     * Add a node to the list of dependencies.  Only add it if its not an input
+     * or output of this node, that is, it is at least one step away.  The node
+     * being added must benefit from this node being peepholed.
+     */
+    Node addDep( Node dep ) {
+        return addDep(dep,false);
+    }
+
+    // A bulk Phi inspects its users' partitions. Def-to-use propagation does
+    // not revisit that producer when an immediate user's partition changes.
+    Node addDepForwards(Node dep) { return addDep(dep,true); }
+
+    private Node addDep(Node dep, boolean forwards) {
+        // Running peepholes during the big assert cannot have side effects
+        // like adding dependencies.
+        if( IterPeeps.midAssert() ) return this;
+        var obs = IterPeeps.midAssert() ? null : Parser.PARSER == null ? null : Parser.PARSER._obs;
+        if( obs != null ) obs.dep(this, dep);
+        if( _deps==null ) _deps = new Ary<>(Node.class);
+        if( _deps   .find(dep) != -1 ) return this; // Already on list
+        if( !forwards && _inputs .find(dep) != -1 ) return this; // No need for deps on immediate neighbors
+        if( !forwards && _outputs.find(dep) != -1 ) return this;
+        _deps.add(dep);
+        return this;
+    }
+
+    // Move the dependents onto a worklist, and clear for future dependents.
+    public void moveDepsToWorklist( ) {
+        if( _deps==null ) return;
+        IterPeeps.addAll(_deps);
+        _deps.clear();
+    }
+
+    // Global Value Numbering.  Hash over opcode and inputs; hits in this table
+    // are structurally equal.
+    public static final HashMap<Node,Node> GVN = new HashMap<>();
+
+    // Two nodes are equal if they have the same inputs and the same "opcode"
+    // which means the same Java class, plus same internal parts.
+    @Override public final boolean equals( Object o ) {
+        if( o==this ) return true;
+        if( o.getClass() != getClass() ) return false;
+        Node n = (Node)o;
+        int len = _inputs.size();
+        if( len != n._inputs.size() ) return false;
+        for( int i=0; i<len; i++ )
+            if( in(i) != n.in(i) )
+                return false;
+        return eq(n);
+    }
+    // Subclasses add extra checks (such as ConstantNodes have same constant),
+    // and can assume "this!=n" and has the same Java class.
+    boolean eq( Node n ) { return true; }
+
+    // Cached hash.  If zero, then not computed AND this Node is NOT in the GVN
+    // table - and can have its edges hacked (which will change his hash
+    // anyway).  If Non-Zero then this Node is IN the GVN table, or is being
+    // probed to see if it can be inserted.  His edges are "locked", because
+    // hacking his edges will change his hash.
+    int _hash;
+
+    // If the _hash is set, then the Node is in the GVN table; remove it.
+    void unlock() {
+        if( _hash==0 ) return;
+        Node old = GVN.remove(this); // Pull from table
+        assert old==this;
+        _hash=0;                // Out of table now
+    }
+
+    // Hash of opcode and inputs
+    @Override public final int hashCode() {
+        if( _hash != 0 ) return _hash;
+        int hash = hash();
+        for( Node n : _inputs )
+            if( n != null )
+                hash = hash ^ (hash<<17) ^ (hash>>13) ^ n._nid;
+        if( hash==0 ) hash = 0xDEADBEEF; // Bad hash, so use some junky thing
+        return (_hash=hash);
+    }
+    // Subclasses add extra hash info (such as ConstantNodes constant)
+    int hash() { return 0; }
+
+    // ------------------------------------------------------------------------
+    //
+
+    /** Is this Node Memory related */
+    public boolean isMem() { return false; }
+
+    // Semantic change to the graph (so NOT a peephole), used by the Parser.
+    // If any input is a float, flip to a float-flavored opcode and widen any
+    // non-float input.
+    public final Node widen() {
+        if( !hasFloatInput() ) return this;
+        Node flt = copyF();
+        if( flt==null ) return this;
+        for( int i=1; i<nIns(); i++ )
+            flt.setDef(i, in(i)._type instanceof TypeFloat ? in(i) : new ToFloatNode(in(i)).peephole());
+        kill();
+        return flt;
+    }
+    private boolean hasFloatInput() {
+        for( int i=1; i<nIns(); i++ )
+            if( in(i)._type instanceof TypeFloat )
+                return true;
+        return false;
+    }
+    Node copyF() { return null; }
+
+    // ------------------------------------------------------------------------
+    // Peephole utilities
+
+    // Swap inputs without letting either input go dead during the swap.
+    Node swap12() {
+        unlock();               // Hash is order dependent
+        Node tmp = in(1);
+        _inputs.set(1,in(2));
+        _inputs.set(2,tmp);
+        return this;
+    }
+
+    /**
+     * Does this node contain all constants?  Ignores in(0), as is usually
+     * control.  In an input is not a constant, we add dep as a dependency to
+     * it because dep can make progress if the input becomes a constant later.
+     * It is sufficient for one of the non-const inputs to have the dependency,
+     * so we don't bother checking the rest.
+     */
+    boolean allCons(Node dep) {
+        for( int i=1; i<nIns(); i++ )
+            if( !(in(i)._type.isConstant()) ) {
+                in(i).addDep(dep); // If in(i) becomes a constant later, will trigger some peephole
+                return false;
+            }
+        return true;
+    }
+
+    // Make a shallow copy (same class) of this Node, with given inputs and
+    // empty outputs and a new Node ID.  The original inputs are ignored.
+    // Does not need to be implemented in isCFG() nodes.
+    Node copy(Node lhs, Node rhs) { throw Utils.TODO("Binary ops need to implement copy"); }
+
+    // Exact-class copy preserving operation attributes, with fresh identity
+    // and no edges, dependencies, or GVN membership.
+    public final Node copyEmpty() {
+        Node n;
+        try { n = (Node)clone(); }
+        catch( CloneNotSupportedException e ) { throw new AssertionError(e); }
+        n._nid = UNIQUE_ID++;
+        n._inputs = new Ary<>(Node.class);
+        n._outputs = new Ary<>(Node.class);
+        n._deps = null;
+        n._hash = 0;
+        return n;
+    }
+
+    // Report any post-optimize errors
+    String err() { return null; }
+
+    /**
+     * Used to allow repeating tests in the same JVM.  This just resets the
+     * Node unique id generator, and is done as part of making a new Parser.
+     */
+    public static void reset() {
+        UNIQUE_ID = 1;
+        GVN.clear();
+        ITER_CNT = ITER_NOP_CNT = 0;
+    }
+
+    // Utility to walk the entire graph applying a function; return the first
+    // not-null result.
+    private static final BitSet WVISIT = new BitSet();
+    final public <E> E walk( Function<Node,E> pred ) {
+        assert WVISIT.isEmpty();
+        try { return _walk(pred); }
+        finally { WVISIT.clear(); }
+    }
+
+    private <E> E _walk( Function<Node,E> pred ) {
+        if( WVISIT.get(_nid) ) return null; // Been there, done that
+        WVISIT.set(_nid);
+        E x = pred.apply(this);
+        if( x != null ) return x;
+        for( Node def : _inputs  )  if( def != null && (x = def._walk(pred)) != null ) return x;
+        for( Node use : _outputs )  if( use != null && (x = use._walk(pred)) != null ) return x;
+        return null;
+    }
+
+    /**
+     * Debugging utility to find a Node by index
+     */
+    public Node find(int nid) {
+        return walk( n -> n._nid==nid ? n : null );
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/NotNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/NotNode.java
new file mode 100644
index 00000000..b9cf4904
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/NotNode.java
@@ -0,0 +1,39 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.type.*;
+
+public class NotNode extends Node {
+    public NotNode(Node in) { super(null, in); }
+
+    @Override public String label() { return "Not"; }
+
+    @Override protected String format() { return "(!%1)"; }
+
+    @Override
+    public Type compute() {
+        Type t0 = in(1)._type;
+        if( t0.isHigh() ) return TypeInteger.BOOL.dual();
+        switch( t0 ) {
+        case TypeInteger i0:  return i0._max < 0 || i0._min > 0 ? TypeInteger.FALSE : (i0==TypeInteger.ZERO ? TypeInteger.TRUE : TypeInteger.BOOL);
+        case TypeFloat   i0:
+            return i0.isConstant() ? TypeInteger.constant(i0.value()==0 ? 1 : 0) : TypeInteger.BOOL;
+        case TypeMemPtr p0:
+            // top->top, bot->bot, null->1, *void->0, not-null ptr->0, ptr/nil->bot
+            // If input in null then true
+            // If input is not null ptr then false
+            if( p0 == TypeMemPtr.NULLPTR ) return TypeInteger.TRUE;
+            if( !p0._nil )                 return TypeInteger.FALSE;
+            return TypeInteger.BOOL;
+        case Type t:
+            if( t0.getClass() != Type.class )
+                // Only doing NOT on ints and ptrs
+                throw Utils.TODO();
+            return TypeInteger.BOOL;
+        }
+    }
+
+    @Override
+    public Node idealize() { return null; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/OrNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/OrNode.java
new file mode 100644
index 00000000..5be31b88
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/OrNode.java
@@ -0,0 +1,58 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class OrNode extends Node {
+    public OrNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Or"; }
+
+    @Override protected String format() { return "(%1|%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i0 &&
+            t2 instanceof TypeInteger i1 ) {
+            if( i0.isConstant() && i1.isConstant() )
+                return TypeInteger.constant(i0.value()|i1.value());
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // Or of 0.  We do not check for (0|x) because this will already
+        // canonicalize to (x|0)
+        if( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==0 )
+            return lhs;
+
+        // Move constants to RHS: con*arg becomes arg*con
+        if ( t1.isConstant() && !t2.isConstant() )
+            return swap12();
+
+        // Do we have ((x | (phi cons)) | con) ?
+        // Do we have ((x | (phi cons)) | (phi cons)) ?
+        // Push constant up through the phi: x | (phi con0|con0 con1|con1...)
+        Node phicon = AddNode.phiCon(this,true);
+        if( phicon!=null ) return phicon;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new OrNode(lhs,rhs); }
+    @Override String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '|' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '|' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/OutNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/OutNode.java
new file mode 100644
index 00000000..dbac136b
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/OutNode.java
@@ -0,0 +1,7 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.simple.Ary;
+
+public interface OutNode {
+    Ary<Node> outs();
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/PhiNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/PhiNode.java
new file mode 100644
index 00000000..942748e7
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/PhiNode.java
@@ -0,0 +1,201 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMem;
+import com.seaofnodes.simple.Utils;
+
+
+public class PhiNode extends Node {
+
+    final String _label;
+
+    // The Phi type we compute must stay within the domain of the Phi.
+    // Example Int stays Int, Ptr stays Ptr, Control stays Control, Mem stays Mem.
+    final Type _declaredType;
+
+    public PhiNode(String label, Type declaredType, Node... inputs) { super(inputs); _label = label;  assert declaredType!=null; _declaredType = declaredType; }
+
+    public static PhiNode make(String label, Type type, Node... inputs) {
+        return type instanceof TypeMem ? new BulkMemPhiNode(label,inputs) : new PhiNode(label,type,inputs);
+    }
+
+    @Override public String label() { return "Phi_"+MemOpNode.mlabel(_label); }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        if( !(region() instanceof RegionNode r) || r.inProgress() )
+            p.p("Z");
+        p.p("Phi(");
+        for( Node in : _inputs ) p.n(in).p(",");
+        return p.unchar(',').close();
+    }
+
+    public CFGNode region() { return (CFGNode)in(0); }
+    @Override public boolean isMultiTail() { return true; }
+    @Override public boolean isMem() { return _declaredType instanceof TypeMem; }
+
+    @Override
+    public Type compute() {
+        if( !(region() instanceof RegionNode r) )
+            return region()._type==Type.XCONTROL ? (_type instanceof TypeMem ? TypeMem.TOP : Type.TOP) : _type;
+        // During parsing Phis have to be computed type pessimistically.
+        if( r.inProgress() ) return _declaredType;
+        // Set type to local top of the starting type
+        Type t = _declaredType.lub();
+        for (int i = 1; i < nIns(); i++)
+            // If the region's control input is live, add this as a dependency
+            // to the control because we can be peeped should it become dead.
+            if( r.in(i).addDep(this)._type != Type.XCONTROL )
+                t = t.meet(in(i)._type);
+        return t;
+    }
+
+    @Override
+    public Node idealize() {
+        if( !(region() instanceof RegionNode r ) )
+            return in(1);       // Input has collapse to e.g. starting control.
+        if( r.inProgress() || r.nIns()<=1 )
+            return null;        // Input is in-progress
+
+        // If we have only a single unique input, become it.
+        Node live = singleUniqueInput();
+        if (live != null)
+            return live;
+
+        // Phi(op(a,b,...),op(c,d,...)) -> op(Phi(a,c),Phi(b,d),...).
+        Node down;
+        if( same_op() && (down=drop_same_op())!=null ) return down;
+
+        // If merging Phi(N, cast(N)) - we are losing the cast JOIN effects, so just remove.
+        if( nIns()==3 ) {
+            if( in(1) instanceof CastNode cast && cast.in(1).addDep(this)==in(2) ) return in(2);
+            if( in(2) instanceof CastNode cast && cast.in(1).addDep(this)==in(1) ) return in(1);
+        }
+        // If merging a null-checked null and the checked value, just use the value.
+        // if( val ) ..; phi(Region,False=0/null,True=val);
+        // then replace with plain val.
+        if( nIns()==3 ) {
+            int nullx = -1;
+            if( in(1)._type == in(1)._type.makeInit() ) nullx = 1;
+            if( in(2)._type == in(2)._type.makeInit() ) nullx = 2;
+            if( nullx != -1 ) {
+                Node val = in(3-nullx);
+                if( r.idom(this).addDep(this) instanceof IfNode iff && iff.pred().addDep(this)==val ) {
+                    // Must walk the idom on the null side to make sure we hit False.
+                    CFGNode idom = (CFGNode)r.in(nullx);
+                    while( idom.nIns() > 0 && idom.in(0) != iff ) idom = idom.idom();
+                    if( idom instanceof CProjNode proj && proj._idx==1 )
+                        return val;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private boolean same_op() {
+        Node op = in(1);
+        if( op instanceof CFGNode || op instanceof ConstantNode || op instanceof PhiNode ||
+            op instanceof ProjNode || op instanceof NewNode || op instanceof ScopeNode || op instanceof MemMergeNode ) return false;
+        // A bulk Phi must split its aliases before factoring precise Stores.
+        if( this instanceof BulkMemPhiNode ) return false;
+        // Bulk splitting currently identifies parallel slices by Region/alias.
+        // Factoring can introduce another slice at a different memory point;
+        // wait until that Region's bulk partitioning has finished.
+        if( op instanceof MemOpNode )
+            for( Node use : region()._outputs )
+                if( use instanceof BulkMemPhiNode ) {
+                    use.addDepForwards(this);
+                    return false;
+                }
+        Node busy = null;
+        for( int i=1; i<nIns(); i++ ) {
+            Node n = in(i);
+            if( region().in(i).addDep(this)._type==Type.XCONTROL ||
+                op.getClass()!=n.getClass() || n.nIns()!=op.nIns() || n.in(0)!=null || !op.eq(n) ) return false;
+            if( n instanceof MemOpNode mem && !mem.canDrop((MemOpNode)op,this) ) return false;
+            // Moving a Store must remove the old effect, not duplicate it.
+            // Allow one shared arm: the other arms disappear into the single
+            // factored operation, usually reducing the total operation count.
+            n.addDepForwards(this);
+            if( n.nOuts()>1 ) {
+                for( Node use : n._outputs )
+                    if( use!=null && use!=this ) use.addDepForwards(this);
+                if( n instanceof StoreNode || busy!=null ) return false;
+                busy=n;
+            }
+            for( int j=1; j<n.nIns(); j++ )
+                if( n.in(j) instanceof ScopeNode || ((n.in(j)==null) != (op.in(j)==null)) ) return false;
+        }
+        return true;
+    }
+
+    private Node drop_same_op() {
+        Node op = in(1), cp = op.copyEmpty();
+        cp._type = null;
+        cp.addDef(null);
+        for( int j=1; j<op.nIns(); j++ ) {
+            Node x = op.in(j);
+            boolean different = false;
+            for( int i=2; i<nIns(); i++ )
+                if( in(i).in(j)!=x ) different=true;
+            if( different ) {
+                Node[] ins = new Node[nIns()];
+                ins[0] = region();
+                Type t = Type.TOP;
+                for( int i=1; i<nIns(); i++ ) {
+                    ins[i] = in(i).in(j);
+                    t = t.meet(ins[i]._type);
+                }
+                PhiNode phi = j==1 && op instanceof MemOpNode mem
+                    ? new MemPhiNode(_label,mem._alias,ins)
+                    : PhiNode.make(_label,t.glb(),ins);
+                x = phi.peephole();
+            }
+            cp.addDef(x);
+        }
+        // Factoring must not widen the result (e.g. correlated And operands).
+        if( cp.compute().isa(compute()) ) return cp;
+        cp.kill();
+        return null;
+    }
+
+    /**
+     * If only single unique input, return it
+     */
+    private Node singleUniqueInput() {
+        if( region() instanceof LoopNode loop && loop.entry()._type == Type.XCONTROL )
+            return null;    // Dead entry loops just ignore and let the loop collapse
+        Node live = null;
+        for( int i=1; i<nIns(); i++ ) {
+            // If the region's control input is live, add this as a dependency
+            // to the control because we can be peeped should it become dead.
+            if( region().in(i).addDep(this)._type != Type.XCONTROL && in(i) != this )
+                if( live == null || live == in(i) ) live = in(i);
+                else return null;
+        }
+        return live;
+    }
+
+    @Override
+    boolean allCons(Node dep) {
+        if( !(region() instanceof RegionNode r) ) return false;
+        // When the region completes (is no longer in progress) the Phi can
+        // become a "all constants" Phi, and the "dep" might make progress.
+        addDep(dep);
+        if( r.inProgress() ) return false;
+        return super.allCons(dep);
+    }
+
+    // True if last input is null
+    public final boolean inProgress() {
+        return in(nIns()-1) == null;
+    }
+
+    // Never equal if inProgress
+    @Override boolean eq( Node n ) {
+        return !inProgress();
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ProjNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ProjNode.java
new file mode 100644
index 00000000..668e20ad
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ProjNode.java
@@ -0,0 +1,47 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMem;
+import com.seaofnodes.simple.type.TypeTuple;
+
+
+public class ProjNode extends Node {
+
+    // Which slice of the incoming multipart value
+    public final int _idx;
+
+    // Debugging label
+    public final String _label;
+
+    public ProjNode(Node ctrl, int idx, String label) {
+        super(ctrl);
+        _idx = idx;
+        _label = label;
+    }
+
+    @Override public String label() { return _label; }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p(_label); }
+
+    @Override public CFGNode cfg0() { return in(0).cfg0(); }
+
+    @Override public boolean isMultiTail() { return in(0).isMultiHead(); }
+    @Override public boolean isMem() { return _type instanceof TypeMem; }
+
+    @Override
+    public Type compute() {
+        Type t = in(0)._type;
+        return t instanceof TypeTuple tt ? tt._types[_idx] : Type.BOTTOM;
+    }
+
+    @Override public Node idealize() { return null; }
+
+    @Override
+    boolean eq( Node n ) { return _idx == ((ProjNode)n)._idx; }
+
+    @Override
+    int hash() { return _idx; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ReadOnlyNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ReadOnlyNode.java
new file mode 100644
index 00000000..fa4e0242
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ReadOnlyNode.java
@@ -0,0 +1,26 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMemPtr;
+
+
+/**
+ * Cast a pointer to read-only
+ */
+public class ReadOnlyNode extends Node {
+    public ReadOnlyNode( Node n ) { super(null,n); }
+    @Override public String label() { return "ReadOnly"; }
+
+    @Override protected String format() { return "(const)%1"; }
+    @Override public Type compute() {
+        Type t = in(1)._type;
+        return t instanceof TypeMemPtr tmp ? tmp.makeRO() : t;
+    }
+
+    @Override public Node idealize() {
+        if( in(1)._type instanceof TypeMemPtr tmp && tmp.isFinal() )
+            return in(1);
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/RegionNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/RegionNode.java
new file mode 100644
index 00000000..27866139
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/RegionNode.java
@@ -0,0 +1,119 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.type.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+
+public class RegionNode extends CFGNode {
+
+    public RegionNode(Node... nodes) { super(nodes); }
+
+    @Override
+    public String label() { return "Region"; }
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.p(label());
+    }
+
+    @Override public boolean isMultiHead() { return true; }
+    @Override public boolean blockHead() { return true; }
+
+    @Override
+    public Type compute() {
+        if( inProgress() ) return Type.CONTROL;
+        Type t = Type.XCONTROL;
+        for (int i = 1; i < nIns(); i++)
+            t = t.meet(in(i)._type);
+        return t;
+    }
+
+    @Override
+    public Node idealize() {
+        if( inProgress() ) return null;
+        // Delete dead paths into a Region
+        int path = findDeadInput();
+        if( path != 0 &&
+            // Do not delete the entry path of a loop (ok to remove the back
+            // edge and make the loop a single-entry Region which folds away
+            // the Loop).  Folding the entry path confused the loop structure,
+            // moving the backedge to the entry point.
+            !(this instanceof LoopNode loop && loop.entry()==in(path)) ) {
+            // Cannot use the obvious output iterator here, because a Phi
+            // deleting an input might recursively delete *itself*.  This
+            // shuffles the output array, and we might miss iterating an
+            // unrelated Phi. So on rare occasions we repeat the loop to get
+            // all the Phis.
+            int nouts = 0;
+            while( nouts != nOuts() ) {
+                nouts = nOuts();
+                for( int i=0; i<nOuts(); i++ )
+                    if( out(i) instanceof PhiNode phi && phi.nIns()==nIns() ) {
+                        phi.delDef(path);
+                        IterPeeps.addAll(phi._outputs);
+                    }
+            }
+            return isDead() ? Parser.XCTRL : delDef(path);
+        }
+        // If down to a single input, become that input
+        if( nIns()==2 && !hasPhi() )
+            return in(1);       // Collapse if no Phis; 1-input Phis will collapse on their own
+
+        // If a CFG diamond with no merging, delete: "if( pred ) {} else {};"
+        if( !hasPhi() &&       // No Phi users, just a control user
+            in(1) instanceof CProjNode p1 &&
+            in(2) instanceof CProjNode p2 &&
+            p1.addDepForwards(this).in(0)==p2.addDepForwards(this).in(0) &&
+            p1.in(0) instanceof IfNode iff )
+            return iff.ctrl();
+
+        return null;
+    }
+
+    private int findDeadInput() {
+        for( int i=1; i<nIns(); i++ )
+            if( in(i)._type==Type.XCONTROL )
+                return i;
+        return 0;               // All inputs alive
+    }
+
+    private boolean hasPhi() {
+        for( Node phi : _outputs )
+            if( phi instanceof PhiNode )
+                return true;
+        return false;
+    }
+
+    // Immediate dominator of Region is a little more complicated.
+    @Override public int idepth() {
+        if( _idepth!=0 ) return _idepth;
+        int depth=0;
+        for( Node n : _inputs )
+            if( n!=null )
+                depth = Math.max(depth,((CFGNode)n).idepth()+1);
+        return cacheIDepth(depth);
+    }
+
+    @Override public CFGNode idom(Node dep) {
+        CFGNode lca = null;
+        // Recompute from predecessors: CFG edits can change the dominator.
+        for( int i=1; i<nIns(); i++ )
+            lca = cfg(i).domLCA(lca,dep);
+        return lca;
+    }
+
+    // True if last input is null
+    public final boolean inProgress() {
+        return nIns()>1 && in(nIns()-1) == null;
+    }
+
+    // Never equal if inProgress
+    @Override boolean eq( Node n ) {
+        return !inProgress();
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ReturnNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
new file mode 100644
index 00000000..6c773c42
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
@@ -0,0 +1,42 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.*;
+
+
+/** Keeps all preceding memory effects and the return value alive: {ctrl, $mem, value}. */
+public class ReturnNode extends CFGNode {
+
+    public ReturnNode(Node ctrl, Node data, ScopeNode scope) {
+        // A synthetic never-taken loop exit has no source scope.
+        super(ctrl, scope == null ? null : scope.mem(), data);
+    }
+
+    public Node ctrl() { return in(0); }
+    public Node mem () { return in(1); }
+    public Node expr() { return in(2); }
+
+    @Override
+    public String label() { return "Return"; }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        p.p("return ");
+        p.n(expr());
+        return p.p(";");
+    }
+
+    @Override
+    public Type compute() {
+        // Return exposes the complete memory state.
+        return TypeTuple.make(ctrl()._type,TypeMem.BOT,expr()._type);
+    }
+
+    @Override
+    public Node idealize() {
+        if( ctrl()._type==Type.XCONTROL )
+            return ctrl();
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/RoundF32Node.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/RoundF32Node.java
new file mode 100644
index 00000000..78e7698c
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/RoundF32Node.java
@@ -0,0 +1,33 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+
+
+public class RoundF32Node extends Node {
+    public RoundF32Node(Node lhs) { super(null, lhs); }
+
+    @Override public String label() { return "RoundF32"; }
+
+    @Override protected String format() { return "((f32)%1)"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeFloat i0 && i0.isConstant() )
+            return TypeFloat.constant((float)i0.value());
+        return in(1)._type;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Type t1 = lhs._type;
+
+        // RoundF32 of float
+        if( t1 instanceof TypeFloat tf && tf._sz==32 )
+            return lhs;
+
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/SarNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/SarNode.java
new file mode 100644
index 00000000..44233b3d
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/SarNode.java
@@ -0,0 +1,54 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class SarNode extends Node {
+    public SarNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Sar"; }
+
+    @Override protected String format() { return "(%1>>%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if (t1 instanceof TypeInteger i0 &&
+            t2 instanceof TypeInteger i1) {
+            if( i0 == TypeInteger.ZERO )
+                return TypeInteger.ZERO;
+            if( i0.isConstant() && i1.isConstant() )
+                return TypeInteger.constant(i0.value()>>i1.value());
+            if( i1.isConstant() ) {
+                int log = (int)i1.value();
+                return TypeInteger.make(-1L<<(63-log),(1L<<(63-log))-1);
+            }
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t2 = rhs._type;
+
+        // Sar of 0.
+        if( t2.isConstant() && t2 instanceof TypeInteger i && (i.value()&63)==0 )
+            return lhs;
+
+        // TODO: x >> 3 >> (y ? 1 : 2) ==> x >> (y ? 4 : 5)
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new SarNode(lhs,rhs); }
+    @Override String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '>>' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '>>' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ScopeNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ScopeNode.java
new file mode 100644
index 00000000..753abe90
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ScopeNode.java
@@ -0,0 +1,416 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.Ary;
+import com.seaofnodes.simple.type.*;
+import java.util.*;
+
+/**
+ * The Scope node is purely a parser helper - it tracks names to nodes with a
+ * stack of variable records.
+ */
+public class ScopeNode extends Node {
+
+    /**
+     * The control is a name that binds to the currently active control
+     * node in the graph
+     */
+    public static final String CTRL = "$ctrl";
+    public static final String ARG0 = "arg";
+    public static final String MEM0 = "$mem";
+
+    /** The tracked fields are now complex enough to deserve a array-of-structs layout
+     */
+    public static class Var {
+        public final int _idx;       // index in containing scope
+        public final String _name;   // Declared name
+        private Type _type;          // Declared type
+        public final boolean _final; // Final field
+        public Var(int idx, String name, Type type, boolean xfinal) {
+            _idx = idx;
+            _name = name;
+            _type = type;
+            _final = xfinal;
+        }
+        public Type type() {
+            if( !_type.isFRef() ) return _type;
+            // Update self to no longer use the forward ref type
+            Type def = Parser.TYPES.get(((TypeMemPtr)_type)._obj._name);
+            return (_type=_type.meet(def));
+        }
+        public Type lazyGLB() {
+            Type t = type();
+            return t instanceof TypeMemPtr ? t : t.glb();
+        }
+        @Override public String toString() {
+            return _type.toString()+(_final ? " ": " !")+_name;
+        }
+    }
+
+    public Node in(Var v) { return in(v._idx); }
+
+    @Override public Type compute() { return Type.BOTTOM; }
+    @Override public Node idealize() { return null; }
+
+    // All active/live variables in all nested scopes, all run together
+    public final Ary<Var> _vars;
+
+    // Size of each nested lexical scope
+    public final Ary<Integer> _lexSize;
+
+    // True if parsing inside of a constructor
+    public final Ary<Boolean> _inCons;
+
+    // Extra guards; tested predicates and casted results
+    private final Ary<Node> _guards;
+
+    // A new ScopeNode
+    public ScopeNode() {
+        _type = Type.BOTTOM;
+        _vars   = new Ary<>(Var    .class);
+        _lexSize= new Ary<>(Integer.class);
+        _inCons = new Ary<>(Boolean.class);
+        _guards = new Ary<>(Node   .class);
+    }
+
+    @Override public String label() { return "Scope"; }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        p.p("Scope[ ");
+        int j=1;
+        for( int i=0; i<nIns(); i++ ) {
+            if( j < _lexSize._len && i == _lexSize.at(j) ) { p.p("| "); j++; }
+            Var v = _vars.get(i);
+            p.p(v.type());
+            p.p(" ");
+            if( v._final ) p.p("!");
+            p.p(v._name);
+            p.p("=");
+            Node n = in(i);
+            while( n instanceof ScopeNode loop ) {
+                p.p("Lazy_");
+                n = loop.in(i);
+            }
+            p.n(n);
+            p.p(", ");
+        }
+        return p.unchar(", ").p("]");
+    }
+
+
+    public Node ctrl() { return in(0); }
+    public Node mem() { return in(lookup(MEM0)); }
+    public void mem(Node n) { update(MEM0,n); }
+
+    /**
+     * The ctrl of a ScopeNode is always bound to the currently active
+     * control node in the graph, via a special name '$ctrl' that is not
+     * a valid identifier in the language grammar and hence cannot be
+     * referenced in Simple code.
+     *
+     * @param n The node to be bound to '$ctrl'
+     *
+     * @return Node that was bound
+     */
+    public <N extends Node> N ctrl(N n) { return setDef(0,n); }
+
+    public void push() { push(false); }
+    public void push(boolean inCon) {
+        assert _lexSize._len==_inCons._len;
+        _lexSize.push(_vars.size());
+        _inCons.push(inCon);
+    }
+    public void pop() {
+        assert _lexSize._len==_inCons._len;
+        int n = _lexSize.pop();
+        _inCons.pop();
+        popUntil(n);
+        _vars.setLen(n);
+    }
+
+    // Allocation fields live in the scope immediately outside the constructor
+    // block. Nested blocks retain that permission; surrounding bindings do not.
+    public boolean canInit(Var v) {
+        for( int i=_inCons._len-1; i>0; i-- )
+            if( _inCons.at(i) )
+                return v._idx >= _lexSize.at(i-1) && v._idx < _lexSize.at(i);
+        return false;
+    }
+
+    public boolean inCon() { return _inCons.last(); }
+
+    // Find name in reverse, return an index into _vars or -1.  Linear scan
+    // instead of hashtable, but probably doesn't matter until the scan
+    // typically hits many dozens of variables.
+    int find( String name ) {
+        for( int i=_vars.size()-1; i>=0; i-- )
+            if( _vars.get(i)._name.equals(name) )
+                return i;
+        return -1;
+    }
+
+    /**
+     * Create a new variable name in the current scope
+     */
+    public boolean define( String name, Type declaredType, boolean xfinal, Node init ) {
+        assert name.charAt(0)!='$' || _lexSize.size()==1; // Later scopes do not define memory
+        if( _lexSize._len > 1 )
+            for( int i=_vars.size()-1; i>=_lexSize.last(); i-- )
+                if( _vars.get(i)._name.equals(name) )
+                    return false;   // Double define
+        _vars.add(new Var(nIns(),name,declaredType,xfinal));
+        addDef(init);
+        return true;
+    }
+
+    /**
+     * Lookup a name in all scopes starting from most deeply nested.
+     *
+     * @param name Name to be looked up
+     * @return null if not found, or the implementing Node
+     */
+    public Var lookup( String name ) {
+        int idx = find(name);
+        // -1 is missed in all scopes, not found
+        return idx == -1 ? null : update(_vars.at(idx),null);
+    }
+
+    /**
+     * If the name is present in any scope, then redefine else null
+     *
+     * @param name Name being redefined
+     * @param n    The node to bind to the name
+     */
+    public void update( String name, Node n ) {
+        int idx = find(name);
+        assert idx>=0;
+        update(_vars.at(idx),n);
+    }
+
+    public Var update( ScopeNode.Var v, Node st ) {
+        Node old = in(v._idx);
+        if( old instanceof ScopeNode loop ) {
+            // Lazy Phi!
+            Node def = loop.in(v._idx);
+            old = def instanceof PhiNode phi && loop.ctrl()==phi.region()
+                // Loop already has a real Phi, use it
+                ? def
+                // Set real Phi in the loop head
+                // The phi takes its one input (no backedge yet) from a recursive
+                // lookup, which might have insert a Phi in every loop nest.
+                : loop.setDef(v._idx,PhiNode.make(v._name, v.lazyGLB(), loop.ctrl(), loop.in(loop.update(v,null)._idx),null).peephole());
+            setDef(v._idx,old);
+        }
+        if( st!=null ) setDef(v._idx,st); // Set new value
+        return v;
+    }
+
+    /**
+     * Duplicate a ScopeNode; including all levels, up to Nodes.  So this is
+     * neither shallow (would dup the Scope but not the internal HashMap
+     * tables), nor deep (would dup the Scope, the HashMap tables, but then
+     * also the program Nodes).
+     * <p>
+     * If the {@code loop} flag is set, the edges are filled in as the original
+     * Scope, as an indication of Lazy Phis at loop heads.  The goal here is to
+     * not make Phis at loop heads for variables which are never touched in the
+     * loop body.
+     * <p>
+     * The new Scope is a full-fledged Node with proper use<->def edges.
+     */
+    public ScopeNode dup() { return dup(false); }
+    public ScopeNode dup(boolean loop) {
+        ScopeNode dup = new ScopeNode();
+        // Our goals are:
+        // 1) duplicate the name bindings of the ScopeNode across all stack levels
+        // 2) Make the new ScopeNode a user of all the nodes bound
+        // 3) Ensure that the order of defs is the same to allow easy merging
+        dup._vars   .addAll(_vars   );
+        dup._lexSize.addAll(_lexSize);
+        dup._inCons .addAll(_inCons );
+        dup._guards .addAll(_guards );
+        // The dup'd guards all need dup'd keepers, to keep proper accounting
+        // when later removing all guards
+        for( Node n : _guards )
+            if( !(n instanceof CFGNode) )
+                n.keep();
+        dup.addDef(ctrl());     // Control input is just copied
+
+        // Memory is one binding, with the same lazy loop Phi as scalar names.
+        for( int i=1; i<nIns(); i++ )
+            dup.addDef(loop ? this : in(i));
+        return dup;
+    }
+
+    /**
+     * Merges the names whose node bindings differ, by creating Phi node for such names
+     * The names could occur at all stack levels, but a given name can only differ in the
+     * innermost stack level where the name is bound.
+     *
+     * @param that The ScopeNode to be merged into this
+     * @return A new node representing the merge point
+     */
+    public RegionNode mergeScopes(ScopeNode that) {
+        RegionNode r = (RegionNode) ctrl(new RegionNode(null,ctrl(), that.ctrl()).keep());
+        _merge(that,r);
+        that.kill();            // Kill merged scope
+        IterPeeps.add(r);
+        return r.unkeep();
+    }
+
+    private void _merge(ScopeNode that, RegionNode r) {
+        for( int i = 1; i < nIns(); i++)
+            if( in(i) != that.in(i) ) { // No need for redundant Phis
+                // If we are in lazy phi mode we need to a lookup
+                // by name as it will trigger a phi creation
+                Var v = _vars.at(i);
+                Node lhs = this.in(this.update(v,null));
+                Node rhs = that.in(that.update(v,null));
+                setDef(i, PhiNode.make(v._name, v.type(), r, lhs, rhs).peephole());
+            }
+    }
+
+    // peephole the backedge scope into this loop head scope
+    // We set the second input to the phi from the back edge (i.e. loop body)
+    public void endLoop(ScopeNode back, ScopeNode exit ) {
+        Node ctrl = ctrl();
+        assert ctrl instanceof LoopNode loop && loop.inProgress();
+        ctrl.setDef(2,back.ctrl());
+
+        _endLoop(this,back,exit);
+        back.kill();            // Loop backedge is dead
+        // Now one-time do a useless-phi removal
+        _useless();
+    }
+
+    // Fill in the backedge of any inserted Phis
+    void _endLoop( ScopeNode scope, Node back, Node exit ) {
+        for( int i=1; i<nIns(); i++ ) {
+            if( back.in(i) != scope ) {
+                PhiNode phi = (PhiNode)in(i);
+                assert phi.region()==scope.ctrl() && phi.in(2)==null;
+                phi.setDef(2,back.in(i)); // Fill backedge
+            }
+            if( exit.in(i) == scope ) // Replace a lazy-phi on the exit path also
+                exit.setDef(i,in(i));
+        }
+    }
+
+
+    // Now one-time do a useless-phi removal
+    void _useless( ) {
+        for( int i=1; i<nIns(); i++ ) {
+            if( in(i) instanceof PhiNode phi ) {
+                // Do an eager useless-phi removal
+                Node in = phi.peephole();
+                IterPeeps.addAll(phi._outputs);
+                phi.moveDepsToWorklist();
+                if( in != phi ) {
+                    if( !phi.iskeep() ) // Keeping phi around for parser elsewhere
+                        phi.subsume(in);
+                    setDef(i,in); // Set the update back into Scope
+                }
+            }
+        }
+    }
+
+    // Up-casting: using the results of an If to improve a value.
+    // E.g. "if( ptr ) ptr.field;" is legal because ptr is known not-null.
+    public void addGuards( Node ctrl, Node pred, boolean invert ) {
+        assert ctrl instanceof CFGNode;
+        _guards.add(ctrl);      // Marker between guard sets
+        // add pred & its cast to the normal input list, with special Vars
+        if( ctrl._type == Type.XCONTROL || pred==null || pred.isDead() )
+            return;           // Dead, do not add any guards
+        _addGuards(ctrl,pred,invert);
+    }
+
+    private void _addGuards( Node ctrl, Node pred, boolean invert ) {
+        if( pred==null || pred.isDead() )
+            return;
+        // A single negation is handled below. For !!p (including p != null),
+        // also refine the underlying p without changing the Boolean result.
+        if( pred instanceof NotNode not && not.in(1) instanceof NotNode ) {
+            pred.keep();        // Recursive peepholes may rediscover this Not.
+            _addGuards(ctrl,not.in(1),!invert);
+            pred.unkeep();
+        }
+        // Invert the If conditional
+        if( invert )
+            pred = pred instanceof NotNode not ? not.in(1) : IterPeeps.add(new NotNode(pred).peephole());
+        // This is a zero/null test.
+        // Compute the positive test type.
+        Type tnz   = pred._type.nonZero();
+        Type tcast = tnz.join(pred._type);
+        if( tcast != pred._type ) {
+            Node cast = new CastNode(tnz,ctrl,pred.keep()).peephole().keep();
+            _guards.add(pred);
+            _guards.add(cast);
+            replace(pred,cast);
+        }
+
+        // Compute the negative test type.
+        if( pred instanceof NotNode not ) {
+            Node npred = not.in(1);
+            Type tzero = npred._type.makeZero();
+            Type tzcast= tzero.join(npred._type);
+            if( tzcast != npred._type ) {
+                Node cast = new CastNode(tzero,ctrl,npred.keep()).peephole().keep();
+                _guards.add(npred);
+                _guards.add( cast);
+                replace(npred,cast);
+            }
+        }
+    }
+
+    // Remove matching pred/cast pairs from this guarded region.
+    public void removeGuards( Node ctrl ) {
+        assert ctrl instanceof CFGNode;
+        // Pop the guards up to this region's marker.
+        while( true ) {
+            Node g = _guards.pop();
+            if( g == ctrl ) break;
+            if( g instanceof CFGNode ) continue;
+            g            .unkill(); // Pop/kill cast
+            _guards.pop().unkill(); // Pop/kill pred
+        }
+    }
+
+    // If we find a guarded instance of pred, replace with the upcasted version
+    public Node upcastGuard( Node pred ) {
+        // If finding an instanceof pred, replace with cast.
+        // Otherwise, just pred itself.
+        int i = _guards._len;
+        while( i > 0 ) {
+            Node  cast = _guards.at(--i);
+            if( cast instanceof CFGNode ) continue; // Marker between guard sets
+            Node xpred = _guards.at(--i);
+            if( xpred == pred )
+                return cast;
+        }
+        return pred;
+    }
+
+    // Kill guards also
+    @Override public void kill() {
+        for( Node n : _guards )
+            if( !(n instanceof CFGNode) )
+                n.unkill();
+        _guards.clear();
+        super.kill();
+    }
+
+
+    private Node replace( Node old, Node cast ) {
+        assert old!=null && old!=cast;
+        for( int i=0; i<nIns(); i++ )
+            if( in(i)==old )
+                setDef(i,cast);
+        return cast;
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ShlNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ShlNode.java
new file mode 100644
index 00000000..65dfe684
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ShlNode.java
@@ -0,0 +1,57 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+public class ShlNode extends Node {
+    public ShlNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Shl"; }
+
+    @Override protected String format() { return "(%1<<%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if (t1 instanceof TypeInteger i0 &&
+            t2 instanceof TypeInteger i1 ) {
+            if( i0 == TypeInteger.ZERO )
+                return TypeInteger.ZERO;
+            if( i0.isConstant() && i1.isConstant() )
+                return TypeInteger.constant(i0.value()<<i1.value());
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+
+        if( rhs._type instanceof TypeInteger shl && shl.isConstant() ) {
+            // Shl of 0.
+            if( (shl.value()&63)==0 )
+                return lhs;
+            // (x + c) << i  =>  (x << i) + (c << i)
+            if( lhs instanceof AddNode add && add.addDep(this).in(2)._type instanceof TypeInteger c && c.isConstant() && c!=TypeInteger.ZERO ) {
+                long sum = c.value() << shl.value();
+                if( Integer.MIN_VALUE <= sum  && sum <= Integer.MAX_VALUE )
+                    return new AddNode( new ShlNode(add.in(1),rhs).peephole(), Parser.con(sum) );
+            }
+        }
+
+        // TODO: x << 3 << (y ? 1 : 2) ==> x << (y ? 4 : 5)
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new ShlNode(lhs,rhs); }
+    @Override String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '<<' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '<<' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ShrNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ShrNode.java
new file mode 100644
index 00000000..757fd69e
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ShrNode.java
@@ -0,0 +1,50 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class ShrNode extends Node {
+    public ShrNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Shr"; }
+
+    @Override protected String format() { return "(%1>>>%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if (t1 instanceof TypeInteger i0 &&
+            t2 instanceof TypeInteger i1 ) {
+            if( i0 == TypeInteger.ZERO )
+                return TypeInteger.ZERO;
+            if( i0.isConstant() && i1.isConstant() )
+                return TypeInteger.constant(i0.value()>>>i1.value());
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t2 = rhs._type;
+
+        // Shr of 0.
+        if( t2.isConstant() && t2 instanceof TypeInteger i && (i.value()&63)==0 )
+            return lhs;
+
+        // TODO: x >>> 3 >>> (y ? 1 : 2) ==> x >>> (y ? 4 : 5)
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new ShrNode(lhs,rhs); }
+    @Override String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '>>>' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '>>>' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/StartNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/StartNode.java
new file mode 100644
index 00000000..cefa2d72
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/StartNode.java
@@ -0,0 +1,36 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.*;
+import java.util.HashSet;
+import static com.seaofnodes.simple.Utils.TODO;
+
+/** Start supplies control, whole memory, and the argument, in that order. */
+public class StartNode extends LoopNode implements MultiNode {
+
+    final Type _arg;
+
+    public StartNode(Type arg) { super(null); _arg = arg; _type = compute(); }
+
+    @Override public String label() { return "Start"; }
+
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.p(label());
+    }
+
+    @Override public boolean isMultiHead() { return true; }
+    @Override public boolean blockHead() { return true; }
+    @Override public CFGNode cfg0() { return this; }
+
+    @Override public TypeTuple compute() {
+        return TypeTuple.make(Type.CONTROL,TypeMem.BOT,_arg);
+    }
+
+    @Override public Node idealize() { return null; }
+
+    // No immediate dominator, and idepth==0
+    @Override public int idepth() { return 0; }
+    @Override public CFGNode idom(Node dep) { return null; }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/StopNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/StopNode.java
new file mode 100644
index 00000000..d0eb5750
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/StopNode.java
@@ -0,0 +1,89 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.GlobalCodeMotion;
+
+
+public class StopNode extends CFGNode {
+
+    public final String _src;
+
+    public StopNode(String src) {
+        super();
+        _src = src;
+    }
+
+    @Override
+    public String label() {
+        return "Stop";
+    }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        if( ret()!=null ) return p.n(ret());
+        p.p("Stop[ ");
+        for( Node ret : _inputs )
+            p.n(ret).p(" ");
+        return p.p("]");
+    }
+
+    @Override public boolean blockHead() { return true; }
+
+    // If a single Return, return it.
+    // Otherwise, null because ambiguous.
+    public ReturnNode ret() {
+        return nIns()==1 ? (ReturnNode)in(0) : null;
+    }
+
+    @Override
+    public Type compute() {
+        return Type.BOTTOM;
+    }
+
+    @Override
+    public Node idealize() {
+        int len = nIns();
+        for( int i=0; i<nIns(); i++ )
+            if( in(i)._type==Type.XCONTROL )
+                delDef(i--);
+        if( len != nIns() ) return this;
+        return null;
+    }
+
+    @Override public int idepth() {
+        if( _idepth!=0 ) return _idepth;
+        int d=0;
+        for( Node n : _inputs )
+            if( n!=null )
+                d = Math.max(d,((CFGNode)n).idepth()+1);
+        return cacheIDepth(d);
+    }
+    @Override public CFGNode idom(Node dep) { return null; }
+
+    public Node addReturn(Node node) {
+        return addDef(node);
+    }
+
+    public StopNode iterate() { return IterPeeps.iterate(this).typeCheck().GCM(); }
+    public StopNode typeCheck() {
+        var obs = Parser.PARSER == null ? null : Parser.PARSER._obs;
+        String err = walk(n -> {
+            String msg = n.err();
+            if( msg != null && obs != null ) obs.error(n, msg);
+            return msg;
+        });
+        if( err != null ) throw new RuntimeException(err);
+        if( obs != null ) obs.phase("TypeCheck");
+        return this;
+    }
+    StopNode GCM() {
+        Parser.START.buildLoopTree(this);
+
+        GlobalCodeMotion.buildCFG(this);
+        return this;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/StoreNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/StoreNode.java
new file mode 100644
index 00000000..a5f04dd2
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/StoreNode.java
@@ -0,0 +1,125 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.type.*;
+
+
+/**
+ * Store represents setting a value to a memory based object, in chapter 10
+ * this means a field inside a struct.
+ */
+public class StoreNode extends MemOpNode {
+
+    private final boolean _init; // Initializing writes are allowed to write null
+
+    /**
+     * @param name  The struct field we are assigning to
+     * @param mem   The memory alias node - this is updated after a Store
+     * @param ptr   The ptr to the struct base where we will store a value
+     * @param off   The offset inside the struct base
+     * @param value Value to be stored
+     */
+    public StoreNode(String name, int alias, Type glb, Node mem, Node ptr, Node off, Node value, boolean init) {
+        super(name, alias, glb, mem, ptr, off, value);
+        _init = init;
+    }
+
+    // Debugger label
+    @Override boolean canDrop(MemOpNode other, Node dep) {
+        return super.canDrop(other,dep) && _init==((StoreNode)other)._init;
+    }
+
+    @Override public String  label() { return "st_"+mlabel(); }
+    @Override public boolean isMem() { return true; }
+
+    public Node val() { return in(4); }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        return p.p(".").p(_name).p("=").p( val()).p(";");
+    }
+
+    @Override
+    public Type compute() {
+        Type val = val()._type;
+        if( _declaredType.isFRef() && val instanceof TypeMemPtr tmp && !tmp.isFRef() )
+            _declaredType = tmp;
+        Type t = val.join(_declaredType).meet(MemMergeNode.contents(mem(),_alias,this));
+        return TypeMem.make(_alias,t);
+    }
+
+    @Override
+    public Node idealize() {
+        if( mem() instanceof MemMergeNode merge ) {
+            setDef(1,IterPeeps.add(merge.alias(_alias)));
+            return this;
+        }
+
+
+        // Simple store-after-store on same address.  Should pick up the
+        // required init-store being stomped by a first user store.
+        if( mem() instanceof StoreNode st &&
+            ptr()==st.ptr() && _alias==st._alias &&  // Must check same object
+            off()==st.off() &&  // And same offset
+            ptr()._type instanceof TypeMemPtr && // No bother if weird dead pointers
+            // Must have exactly one use of "this" or you get weird
+            // non-serializable memory effects in the worse case.
+            checkOnlyUse(st) ) {
+            assert _name.equals(st._name); // Equiv class aliasing is perfect
+            setDef(1,st.mem());
+            return this;
+        }
+
+        // Simple store-after-new on same address.  Should pick up the
+        // an init-store being stomped by a first user store.
+        if( mem() instanceof ProjNode st  && st .in(0) instanceof NewNode nnn &&
+            ptr() instanceof ProjNode ptr && ptr.in(0) == nnn &&
+            ptr()._type instanceof TypeMemPtr tmp && // No bother if weird dead pointers
+            // Cannot fold a store of a single element over the array body initializer value
+            !(tmp._obj.isAry() && tmp._obj._fields[1]._alias==_alias) &&
+            // Very sad strong cutout: val has to be legal to hoist to a New
+            // input, which means it cannot depend on the New.  Many many
+            // things are legal here but difficult to check without doing a
+            // full dominator check.  Example failure:
+            // "struct C { C? c; }; C self = new C { c=self; }"
+            val()._type.isHighOrConst() &&
+            // Must have exactly one use of "this" or you get weird
+            // non-serializable memory effects in the worse case.
+            checkOnlyUse(st) &&
+            // Folding away a broken store
+            err()==null ) {
+            nnn.setDef(nnn.findAlias(_alias),val());
+            // Must retype the NewNode
+            nnn  ._type = nnn.  compute();
+            mem()._type = mem().compute();
+            return st;
+        }
+
+        return null;
+    }
+
+    // Check that "mem" has no uses except "this"
+    private boolean checkOnlyUse(Node mem) {
+        if( mem.nOuts()==1 ) return true;
+        // Add deps on the other uses (can be e.g. ScopeNode mid-parse) so that
+        // when the other uses go away we can retry.
+        for( Node use : mem._outputs )
+            if( use != this )
+                use.addDep(this);
+        return false;
+    }
+
+    @Override
+    String err() {
+        String err = super.err();
+        if( err != null ) return err;
+        TypeMemPtr tmp = (TypeMemPtr)ptr()._type;
+        if( tmp._ro || tmp._obj.field(_name)._final )
+            return "Cannot modify final field '"+_name+"'";
+        Type t = val()._type;
+        return _init || t.isa(_declaredType) ? null : "Cannot store "+t+" into field "+_declaredType+" "+_name;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/StructNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/StructNode.java
new file mode 100644
index 00000000..429b49cc
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/StructNode.java
@@ -0,0 +1,45 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.type.*;
+
+/**
+ * Build a compound object
+ */
+public class StructNode extends Node {
+
+    public TypeStruct _ts;
+
+    @Override public String label() { return _ts==null ? "STRUCT?" : _ts.str(); }
+
+    @Override
+    protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
+        if( _ts==null ) return p.p("STRUCT?");
+        p.p(_ts._name).p(" {");
+        for( int i=0; i<nIns(); i++ ) {
+            p.p(_ts._fields[i]._fname).p(":");
+            p.p(in(i)==null ? Type.BOTTOM : in(i)._type);
+            p.p("; ");
+        }
+        return p.unchar("; ").p("}");
+    }
+
+    @Override
+    public TypeStruct compute() {
+        if( _ts==null ) return TypeStruct.BOT;
+        Field[] fs = new Field[_ts._fields.length];
+        for( int i=0; i<fs.length; i++ )
+            fs[i] = _ts._fields[i].makeFrom(in(i)==null ? Type.TOP : in(i)._type);
+        return TypeStruct.make(_ts._name,fs);
+    }
+
+    @Override
+    public Node idealize() { return null; }
+
+    @Override
+    boolean eq(Node n) { return _ts == ((StructNode)n)._ts; }
+
+    @Override
+    int hash() { return _ts==null ? 0 : _ts.hashCode(); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/SubFNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/SubFNode.java
new file mode 100644
index 00000000..2d218a03
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/SubFNode.java
@@ -0,0 +1,37 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+
+
+public class SubFNode extends Node {
+    public SubFNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "SubF"; }
+
+    @Override protected String format() { return "(%1-%2)"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeFloat i0 &&
+            in(2)._type instanceof TypeFloat i1) {
+            if (i0.isConstant() && i1.isConstant())
+                return TypeFloat.constant(i0.value()-i1.value());
+        }
+        return in(1)._type.meet(in(2)._type);
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Type t2 = in(2)._type;
+
+        // Sub of 0.
+        if ( t2.isConstant() && t2 instanceof TypeFloat i && i.value()==0 )
+            return lhs;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new SubFNode(lhs,rhs); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/SubNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/SubNode.java
new file mode 100644
index 00000000..768cb2bf
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/SubNode.java
@@ -0,0 +1,64 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class SubNode extends Node {
+    public SubNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Sub"; }
+
+    @Override protected String format() { return "(%1-%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i1 &&
+            t2 instanceof TypeInteger i2 ) {
+            if (i1.isConstant() && i2.isConstant())
+                return TypeInteger.constant(i1.value()-i2.value());
+            // Fold ranges like {2-3} - {0-1} into {1-3}.
+            if( !AddNode.overflow(i1._min,-i2._max) &&
+                !AddNode.overflow(i1._max,-i2._min) &&
+                i2._min != Long.MIN_VALUE  )
+                return TypeInteger.make(i1._min-i2._max,i1._max-i2._min);
+        }
+        // Sub of same is 0
+        if( in(1)==in(2) )
+            return TypeInteger.ZERO;
+
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // Keep invalid operands for type checking.
+        if( t1 instanceof TypeInteger x && t2 instanceof TypeInteger y ) {
+            if( y.isConstant() && y.value()==0 ) return lhs;
+            if( x.isConstant() && x.value()==0 ) return new MinusNode(rhs);
+        }
+
+        // x - (-y) is x+y
+        if( rhs instanceof MinusNode minus )
+            return new AddNode(lhs,minus.in(1));
+
+        // (-x) - y is -(x+y)
+        if( lhs instanceof MinusNode minus )
+            return new MinusNode(new AddNode(minus.in(1),rhs).peephole());
+
+        return null;
+    }
+
+    @Override Node copy(Node lhs, Node rhs) { return new SubNode(lhs,rhs); }
+    @Override Node copyF() { return new SubFNode(null,null); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java
new file mode 100644
index 00000000..26cf50e1
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java
@@ -0,0 +1,25 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeFloat;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class ToFloatNode extends Node {
+    public ToFloatNode(Node lhs) { super(null, lhs); }
+
+    @Override public String label() { return "ToFloat"; }
+
+    @Override protected String format() { return "(flt)%1"; }
+
+    @Override
+    public Type compute() {
+        if (in(1)._type instanceof TypeInteger i0 && i0.isConstant() )
+            return TypeFloat.constant(i0.value());
+        return TypeFloat.BOT;
+    }
+
+    @Override public Node idealize() { return null; }
+    @Override Node copy(Node lhs, Node rhs) { return new ToFloatNode(lhs); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/XCtrlNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/XCtrlNode.java
new file mode 100644
index 00000000..056dfba1
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/XCtrlNode.java
@@ -0,0 +1,14 @@
+package com.seaofnodes.simple.node;
+
+import com.seaofnodes.print.ExprPrinter;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.type.Type;
+
+public class XCtrlNode extends CFGNode {
+    public XCtrlNode( ) { super(Parser.START); }
+    @Override public String label() { return "Xctrl"; }
+    @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p("Xctrl"); }
+    @Override  public Type compute() { return Type.XCONTROL; }
+    @Override public Node idealize() { return null; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/node/XorNode.java b/chapter17b/src/main/java/com/seaofnodes/simple/node/XorNode.java
new file mode 100644
index 00000000..ef7273b8
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/node/XorNode.java
@@ -0,0 +1,58 @@
+package com.seaofnodes.simple.node;
+
+
+import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeInteger;
+
+
+public class XorNode extends Node {
+    public XorNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Xor"; }
+
+    @Override protected String format() { return "(%1^%2)"; }
+
+    @Override
+    public Type compute() {
+        Type t1 = in(1)._type, t2 = in(2)._type;
+        if( t1.isHigh() || t2.isHigh() )
+            return TypeInteger.TOP;
+        if( t1 instanceof TypeInteger i0 &&
+            t2 instanceof TypeInteger i1 ) {
+            if( i0.isConstant() && i1.isConstant() )
+                return TypeInteger.constant(i0.value()^i1.value());
+        }
+        return TypeInteger.BOT;
+    }
+
+    @Override
+    public Node idealize() {
+        Node lhs = in(1);
+        Node rhs = in(2);
+        Type t1 = lhs._type;
+        Type t2 = rhs._type;
+
+        // Xor of 0.  We do not check for (0^x) because this will already
+        // canonicalize to (x^0)
+        if( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==0 )
+            return lhs;
+
+        // Move constants to RHS: con*arg becomes arg*con
+        if ( t1.isConstant() && !t2.isConstant() )
+            return swap12();
+
+        // Do we have ((x ^ (phi cons)) ^ con) ?
+        // Do we have ((x ^ (phi cons)) ^ (phi cons)) ?
+        // Push constant up through the phi: x ^ (phi con0^con0 con1^con1...)
+        Node phicon = AddNode.phiCon(this,true);
+        if( phicon!=null ) return phicon;
+
+        return null;
+    }
+    @Override Node copy(Node lhs, Node rhs) { return new XorNode(lhs,rhs); }
+    @Override String err() {
+        if( !(in(1)._type instanceof TypeInteger) ) return "Cannot '^' " + in(1)._type;
+        if( !(in(2)._type instanceof TypeInteger) ) return "Cannot '^' " + in(2)._type;
+        return null;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/print/SimpleGraphAdapter.java b/chapter17b/src/main/java/com/seaofnodes/simple/print/SimpleGraphAdapter.java
new file mode 100644
index 00000000..7ba58e6f
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/print/SimpleGraphAdapter.java
@@ -0,0 +1,42 @@
+package com.seaofnodes.simple.print;
+
+import com.seaofnodes.graph.GraphAdapter;
+import com.seaofnodes.graph.GraphSnapshot.*;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.type.TypeMem;
+
+/** Chapter 17's view of the IR; browser, transport and layout are shared. */
+public class SimpleGraphAdapter extends GraphAdapter<Node> {
+
+    @Override protected String edgeName(Node n, int i) {
+        return n instanceof ScopeNode scope && i < scope._vars.size()
+                ? scope._vars.get(i)._name : null;
+    }
+    @Override protected int projectionIndex(Node n) { return n instanceof ProjNode p ? p._idx : n instanceof CProjNode p ? p._idx : -1; }
+
+    @Override protected Kind kind(Node n) {
+        if( n instanceof StopNode ) return Kind.STOP;
+        if( n instanceof ScopeNode ) return Kind.SCOPE;
+        if( n instanceof StartNode ) return Kind.CTRL;
+        if( n instanceof LoopNode ) return Kind.LOOP;
+        if( n instanceof RegionNode ) return Kind.REGION;
+        if( n instanceof PhiNode ) return Kind.PHI;
+        return n instanceof CFGNode ? Kind.CTRL : isMem(n) ? Kind.MEM : Kind.DATA;
+    }
+
+    @Override protected Role role(Node n, int i) {
+        if( n instanceof ScopeNode || n instanceof ConstantNode || n instanceof XCtrlNode ) return Role.ASSOC;
+        if( n instanceof PhiNode ) return i == 0 ? Role.ASSOC : isMem(n) ? Role.MEM : Role.DATA;
+        if( n instanceof ProjNode || n instanceof CProjNode )
+            return n instanceof CFGNode ? Role.CTRL : isMem(n) ? Role.MEM : Role.DATA;
+        if( n instanceof RegionNode && i == 0 ) return Role.ASSOC;
+        if( i == 0 || n instanceof RegionNode || n instanceof StopNode ) return Role.CTRL;
+        if( i == 1 && (n instanceof MemOpNode || n instanceof ReturnNode || n instanceof NewNode) ) return Role.MEM;
+        Node def = n.in(i);
+        if( def != null && isMem(def) ) return Role.MEM;
+        return Role.DATA;
+    }
+
+    private boolean isMem(Node n) { return n.isMem() || n._type instanceof TypeMem; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/print/SimpleGraphObserver.java b/chapter17b/src/main/java/com/seaofnodes/simple/print/SimpleGraphObserver.java
new file mode 100644
index 00000000..d774967b
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/print/SimpleGraphObserver.java
@@ -0,0 +1,45 @@
+package com.seaofnodes.simple.print;
+
+import com.seaofnodes.graph.GraphCapture;
+import com.seaofnodes.graph.GraphViewer;
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.node.Node;
+import java.util.ArrayList;
+import java.io.IOException;
+
+/** Chapter 17's compilation context; capture and event bookkeeping are shared. */
+public class SimpleGraphObserver extends GraphCapture<Node> {
+    private Parser _parser;
+    private Node _ret;
+    private String _phase;
+    public SimpleGraphObserver() { super(new SimpleGraphAdapter()); }
+    public static void main(String[] args) throws IOException {
+        GraphViewer.run(new SimpleGraphObserver());
+    }
+    @Override protected void compile(String src) {
+        _parser = new Parser(src);
+        _parser._obs = this;
+        _phase = "Parse";
+        _ret = _parser.parse();
+        phase(_phase);
+        _phase = "Iter";
+        com.seaofnodes.simple.IterPeeps.iterate(_parser.STOP);
+        phase(_phase);
+        _phase = "TypeCheck";
+        _parser.STOP.typeCheck();
+    }
+    @Override protected String phase() { return _phase; }
+    @Override protected int pos() { return "Parse".equals(_phase) ? _parser.pos() : -1; }
+    @Override protected void detach() {
+        if( _parser != null ) _parser._obs = null;
+        _parser = null;
+        _ret = null;
+    }
+    @Override protected Node scope() { return _parser._scope; }
+    @Override protected void roots(ArrayList<Node> roots) {
+        roots.add(Parser.START);
+        roots.add(_parser.STOP);
+        roots.addAll(_parser._xScopes);
+        roots.add(_ret);
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/Field.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/Field.java
new file mode 100644
index 00000000..71c2fded
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/Field.java
@@ -0,0 +1,77 @@
+package com.seaofnodes.simple.type;
+
+import com.seaofnodes.simple.Utils;
+import java.util.ArrayList;
+
+/**
+ * Represents a field in a struct. This is not a Type in the type system.
+ */
+public class Field extends Type {
+
+    // The pair {fieldName,type} uniquely identifies a field.
+
+    // Field name
+    public final String _fname;
+    // Type of the field
+    public final Type _type;
+    // Unique memory alias, not sensibly part of a "type" but very convenient here.
+    public final int _alias;
+    // Field must be written to exactly once, no more, no less
+    public final boolean _final;
+
+    private Field(String fname, Type type, int alias, boolean xfinal ) {
+        super(TFLD);
+        _fname = fname;
+        _type  = type;
+        _alias = alias;
+        _final = xfinal;
+    }
+    // Make with existing alias
+    public static Field make( String fname, Type type, int alias, boolean xfinal ) {
+        return new Field(fname,type,alias,xfinal).intern();
+    }
+    public Field makeFrom( Type type ) {
+        return type == _type ? this : new Field(_fname,type,_alias,_final).intern();
+    }
+    @Override public Field makeRO() { return isFinal() ? this : make(_fname,_type.makeRO(),_alias,true);  }
+    @Override public boolean isFinal() { return _final && _type.isFinal(); }
+
+    public static final Field TEST = make("test",TypeInteger.ZERO,-2,false);
+    public static void gather(ArrayList<Type> ts) { ts.add(TEST); }
+
+    @Override Field xmeet( Type that ) {
+        Field fld = (Field)that; // Invariant
+        assert _fname.equals(fld._fname);
+        assert _alias==fld._alias;
+        return make(_fname,_type.meet(fld._type),_alias,_final | fld._final);
+    }
+
+    @Override
+    public Field dual() { return make(_fname,_type.dual(),_alias,!_final); }
+
+    @Override public Field glb() {
+        Type glb = _type.glb();
+        return glb==_type ? this : make(_fname,glb,_alias,_final);
+    }
+
+    @Override public Field lub() {
+        Type lub = _type.lub();
+        return lub==_type ? this : make(_fname,lub,_alias,_final);
+    }
+
+    // Override in subclasses
+    int hash() { return _fname.hashCode() ^ _type.hashCode() ^ _alias ^ (_final ? 1024 : 0); }
+
+    boolean eq(Type t) {
+        Field f = (Field)t;
+        return _fname.equals(f._fname) && _type==f._type && _alias==f._alias && _final==f._final;
+    }
+
+
+    @Override
+    public StringBuilder print( StringBuilder sb ) {
+        return _type.print(sb.append(_final?"":"!").append(_fname).append(":").append(_alias).append(" : "));
+    }
+
+    @Override public String str() { return _fname; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/Type.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/Type.java
new file mode 100644
index 00000000..60afb668
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/Type.java
@@ -0,0 +1,222 @@
+package com.seaofnodes.simple.type;
+
+import com.seaofnodes.simple.Utils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * These types are part of a Monotone Analysis Framework,
+ * @see <a href="https://www.cse.psu.edu/~gxt29/teaching/cse597s21/slides/08monotoneFramework.pdf">see for example this set of slides</a>.
+ * <p>
+ * The types form a lattice; @see <a href="https://en.wikipedia.org/wiki/Lattice_(order)">a symmetric complete bounded (ranked) lattice.</a>
+ * <p>
+ * This wild lattice theory will be needed later to allow us to easily beef up
+ * the analysis and optimization of the Simple compiler... but we don't need it
+ * now, just know that it is coming along in a later Chapter.
+ * <p>g
+ * One of the fun things here is that while the theory is deep and subtle, the
+ * actual implementation is darn near trivial and is generally really obvious
+ * what we're doing with it.  Right now, it's just simple integer math to do
+ * simple constant folding e.g. 1+2 == 3 stuff.
+ */
+
+public class Type {
+    static final HashMap<Type,Type> INTERN = new HashMap<>();
+
+    // ----------------------------------------------------------
+    // Simple types are implemented fully here.  "Simple" means: the code and
+    // type hierarchy are simple, not that the Type is conceptually simple.
+    static final byte TBOT    = 0; // Bottom (ALL)
+    static final byte TTOP    = 1; // Top    (ANY)
+    static final byte TCTRL   = 2; // Ctrl flow bottom
+    static final byte TXCTRL  = 3; // Ctrl flow top (mini-lattice: any-xctrl-ctrl-all)
+    static final byte TSIMPLE = 4; // End of the Simple Types
+    static final byte TINT    = 5; // All Integers; see TypeInteger
+    static final byte TFLT    = 6; // All Integers; see TypeInteger
+    static final byte TTUPLE  = 7; // Tuples; finite collections of unrelated Types, kept in parallel
+    static final byte TMEM    = 8; // All memory (alias 0) or A slice of memory - with specific alias
+    static final byte TMEMPTR = 9; // Memory pointer type
+    static final byte TSTRUCT =10; // Structs; tuples with named fields
+    static final byte TFLD    =11; // Fields into struct
+    static final byte TARRAY  =12; // Array
+
+    public final byte _type;
+
+    public boolean is_simple() { return _type < TSIMPLE; }
+    private static final String[] STRS = new String[]{"Bot","Top","Ctrl","~Ctrl"};
+    protected Type(byte type) { _type = type; }
+
+    public static final Type BOTTOM   = new Type( TBOT   ).intern(); // ALL
+    public static final Type TOP      = new Type( TTOP   ).intern(); // ANY
+    public static final Type CONTROL  = new Type( TCTRL  ).intern(); // Ctrl
+    public static final Type XCONTROL = new Type( TXCTRL ).intern(); // ~Ctrl
+    public static Type[] gather() {
+        ArrayList<Type> ts = new ArrayList<>();
+        ts.add(BOTTOM);
+        ts.add(CONTROL);
+        Field.gather(ts);
+        TypeInteger.gather(ts);
+        TypeFloat.gather(ts);
+        TypeMem.gather(ts);
+        TypeMemPtr.gather(ts);
+        TypeStruct.gather(ts);
+        TypeTuple.gather(ts);
+        int sz = ts.size();
+        for( int i = 0; i < sz; i++ )
+            ts.add(ts.get(i).dual());
+        return ts.toArray(new Type[ts.size()]);
+    }
+
+    // Is high or on the lattice centerline.
+    public boolean isHigh       () { return _type==TTOP || _type==TXCTRL; }
+    public boolean isHighOrConst() { return _type==TTOP || _type==TXCTRL; }
+
+    // Strict constant values, things on the lattice centerline.
+    // Excludes both high and low values
+    public boolean isConstant() { return false; }
+
+    /**
+     * Display Type name in a format that's good for IR printer
+     */
+    public StringBuilder typeName( StringBuilder sb) { return print(sb); }
+
+
+    // ----------------------------------------------------------
+
+    // Notes on Type interning: At the moment it is not easy to reset the
+    // interned types because we hold static references to several types and
+    // these are scattered around.  This means the INTERN cache will retain all
+    // types from every run of the Parser.  For this to work correctly types
+    // must be rigorous about defining when they are the same.  Also types need
+    // to be immutable once defined.  The rationale for interning is
+    // *correctness* with cyclic type definitions.  Simple structural recursive
+    // checks go exponential with merely sharing, but with cycles they will
+    // stack overflow and crash.  Intering means we do not need to have sharing
+    // checks with every type compare, only during interning.
+
+    // Factory method which interns "this"
+    public  <T extends Type> T intern() {
+        T nnn = (T)INTERN.get(this);
+        if( nnn==null )
+            INTERN.put(nnn=(T)this,this);
+        return nnn;
+    }
+
+    private int _hash;          // Hash cache; not-zero when set.
+    @Override
+    public final int hashCode() {
+        if( _hash!=0 ) return _hash;
+        _hash = hash();
+        if( _hash==0 ) _hash = 0xDEADBEEF; // Bad hash from subclass; use some junk thing
+        return _hash;
+    }
+    // Override in subclasses
+    int hash() { return _type; }
+
+    @Override
+    public final boolean equals( Object o ) {
+        if( o==this ) return true;
+        if( !(o instanceof Type t)) return false;
+        if( _type != t._type ) return false;
+        return eq(t);
+    }
+    // Overridden in subclasses; subclass can assume "this!=t" and java classes are same
+    boolean eq(Type t) { return true; }
+
+
+    // ----------------------------------------------------------
+    public final Type meet(Type t) {
+        // Shortcut for the self case
+        if( t == this ) return this;
+        // Same-type is always safe in the subclasses
+        if( _type==t._type ) return xmeet(t);
+        // Reverse; xmeet 2nd arg is never "is_simple" and never equal to "this".
+        if(   is_simple() ) return this.xmeet(t   );
+        if( t.is_simple() ) return t   .xmeet(this);
+        return Type.BOTTOM;     // Mixing 2 unrelated types
+    }
+
+    // Compute meet right now.  Overridden in subclasses.
+    // Handle cases where 'this.is_simple()' and unequal to 't'.
+    // Subclassed xmeet calls can assert that '!t.is_simple()'.
+    Type xmeet(Type t) {
+        assert is_simple(); // Should be overridden in subclass
+        // ANY meet anything is thing; thing meet ALL is ALL
+        if( _type==TBOT || t._type==TTOP ) return this;
+        if( _type==TTOP || t._type==TBOT ) return    t;
+        // 'this' is {TCTRL,TXCTRL}
+        if( !t.is_simple() ) return BOTTOM;
+        // 't' is {TCTRL,TXCTRL}
+        return _type==TCTRL || t._type==TCTRL ? CONTROL : XCONTROL;
+    }
+
+    public Type dual() {
+        return switch( _type ) {
+        case TBOT -> TOP;
+        case TTOP -> BOTTOM;
+        case TCTRL -> XCONTROL;
+        case TXCTRL -> CONTROL;
+        default -> throw Utils.TODO(); // Should not reach here
+        };
+    }
+
+    // ----------------------------------------------------------
+    // Our lattice is defined with a MEET and a DUAL.
+    // JOIN is dual of meet of both duals.
+    public final Type join(Type t) {
+        if( this==t ) return this;
+        return dual().meet(t.dual()).dual();
+    }
+
+    // True if this "isa" t; e.g. 17 isa TypeInteger.BOT
+    public boolean isa( Type t ) { return meet(t)==t; }
+
+    /** Compute greatest lower bound in the lattice */
+    public Type glb() { return _type==TCTRL ? CONTROL : BOTTOM; }
+    /** Compute least upper bound in the lattice */
+    public Type lub() { return _type==TCTRL ? XCONTROL : TOP; }
+
+    // Make an initial/default version of this type.  Typically, 0 for integers
+    // and null for nullable pointers.
+    public Type makeInit() { return this; }
+    // Make a zero version of this type, 0 for integers and null for pointers.
+    public Type makeZero() { return null; }
+    // Make a non-zero version of this type, if possible.  Integers attempt to
+    // exclude zero from their range and pointers become not-null.
+    public Type nonZero() { return glb(); }
+
+    // Writable array slots are invariant in their element access permissions.
+    // Otherwise an alias could insert a readonly pointer into a writable slot.
+    public boolean accessISA(Type dst) { return true; }
+
+    // Is forward-reference
+    public boolean isFRef() { return false; }
+
+    // All reachable struct Fields are final
+    public boolean isFinal() { return true; }
+
+    // Make all reachable struct Fields final
+    public Type makeRO() { return this; }
+
+    // ----------------------------------------------------------
+
+    // Size in bits to hold an instance of this type.
+    // Sizes are expected to be between 1 and 64 bits.
+    // Size 0 means this either takes no space (such as a known-zero field)
+    // or isn't a scalar to be stored in memory.
+    public int log_size() { throw Utils.TODO(); }
+
+    // ----------------------------------------------------------
+    // Useful in the debugger, which calls toString everywhere.
+    // This is a more verbose dev-friendly print.
+    @Override
+    public final String toString() {
+        return print(new StringBuilder()).toString();
+    }
+
+    public StringBuilder print(StringBuilder sb) { return is_simple() ? sb.append(STRS[_type]) : sb;}
+
+    // This is used by error messages, and is a shorted print.
+    public String str() { return STRS[_type]; }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeFloat.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
new file mode 100644
index 00000000..f85abbed
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeFloat.java
@@ -0,0 +1,120 @@
+package com.seaofnodes.simple.type;
+
+import java.util.ArrayList;
+
+/**
+ * Float Type
+ */
+public class TypeFloat extends Type {
+
+    public final static TypeFloat TOP = make((byte)-64, 0);
+    public final static TypeFloat T32 = make((byte)-32, 0);
+    public final static TypeFloat ZERO= make((byte)  0, 0);
+    public final static TypeFloat B32 = make((byte) 32, 0);
+    public final static TypeFloat BOT = make((byte) 64, 0);
+
+    /** +/-64 for double; +/-32 for float, or 0 for constants */
+    public final byte _sz;
+
+    /**
+     * The constant value or 0
+     */
+    public final double _con;
+
+    private TypeFloat(byte sz, double con) {
+        super(TFLT);
+        _sz  = sz ;
+        _con = con;
+    }
+    private static TypeFloat make(byte sz, double con) {
+        return new TypeFloat(sz,con).intern();
+    }
+
+    public static TypeFloat constant(double con) { return make((byte)0, con); }
+
+    public static void gather(ArrayList<Type> ts) { ts.add(ZERO); ts.add(BOT); ts.add(B32); ts.add(constant(3.141592653589793)); }
+
+    // FIXME this display format is problematic
+    // In visualizer '#' gets prepended if its a constant
+    @Override
+    public StringBuilder print(StringBuilder sb) {
+        if( this==TOP ) return sb.append("FltTop");
+        if( this==T32 ) return sb.append("F32Top");
+        if( this==B32 ) return sb.append("F32Bot");
+        if( this==BOT ) return sb.append("FltBot");
+        return sb.append(_con);
+    }
+
+    @Override public String str() {
+        if( this==TOP ) return "~flt";
+        if( this==T32 ) return "~f32";
+        if( this==B32 ) return  "f32";
+        if( this==BOT ) return  "flt";
+        return ""+_con+(isF32() ? "f" : "");
+    }
+
+    /**
+     * Display Type name in a format that's good for IR printer
+     */
+    @Override
+    public StringBuilder typeName(StringBuilder sb) {
+        if( this==TOP ) return sb.append("FltTop");
+        if( this==T32 ) return sb.append("F32Top");
+        if( this==B32 ) return sb.append("F32Bot");
+        if( this==BOT ) return sb.append("FltBot");
+        return sb.append(isF32() ? "F32" : "Flt");
+    }
+
+    boolean isF32() { return ((float)_con)==_con; }
+    @Override public boolean isHigh()        { return _sz< 0; }
+    @Override public boolean isHighOrConst() { return _sz<=0; }
+    @Override public boolean isConstant()    { return _sz==0; }
+
+    @Override public int log_size() {
+        int sz = _sz==0 ? (isF32() ? 32 : 64) : Math.abs(_sz);
+        return _sz==32 ? 2 : 3;
+    }
+
+    public double value() { return _con; }
+
+    @Override
+    public Type xmeet(Type other) {
+        // Invariant from caller: 'this' != 'other' and same class (TypeFloat)
+        TypeFloat i = (TypeFloat)other; // Contract
+        // Larger size in i1, smaller in i0
+        TypeFloat i0 = _sz < i._sz ? this : i;
+        TypeFloat i1 = _sz < i._sz ? i : this;
+
+        if( i1._sz== 64 ) return BOT;
+        if( i0._sz==-64 ) return i1;
+        if( i1._sz== 32 )
+            return i0._sz==0 && !i0.isF32() ? BOT : B32;
+        if( i1._sz!=  0 ) return i1;
+        // i1 is a constant
+        if( i0._sz==-32 )
+            return i1.isF32() ? i1 : BOT;
+        // Since both are constants, and are never equals (contract) unequals
+        // constants fall to bottom
+        return i0.isF32() && i1.isF32() ? B32 : BOT;
+    }
+
+    @Override
+    public Type dual() {
+        if( _sz==0 ) return this; // Constants are a self-dual
+        return make((byte)-_sz,0);
+    }
+
+    @Override public Type glb() { return BOT; }
+    @Override public Type lub() { return TOP; }
+    @Override public TypeFloat makeInit() { return ZERO; }
+    @Override public TypeFloat makeZero() { return ZERO; }
+
+    @Override
+    int hash() { return (int)(Double.hashCode(_con) ^ _sz); }
+    @Override
+    public boolean eq( Type t ) {
+        TypeFloat i = (TypeFloat)t; // Contract
+        return _con==i._con && _sz==i._sz;
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeInteger.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
new file mode 100644
index 00000000..b2979d7b
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
@@ -0,0 +1,133 @@
+package com.seaofnodes.simple.type;
+
+import com.seaofnodes.simple.Utils;
+import java.util.ArrayList;
+
+/**
+ * Integer Type
+ */
+public class TypeInteger extends Type {
+
+    public final static TypeInteger TOP = make(false, 0);
+    public final static TypeInteger BOT = make(false, 1);
+    public final static TypeInteger ZERO= make(0,0);
+    public final static TypeInteger U1  = make(0,1);
+    public final static TypeInteger BOOL= U1;
+    public final static TypeInteger FALSE=ZERO;
+    public final static TypeInteger TRUE= make(1,1);
+    public final static TypeInteger I8  = make(-128,127);
+    public final static TypeInteger I16 = make(-32768,32767);
+    public final static TypeInteger I32 = make(-1L<<31,(1L<<31)-1);
+
+    public final static TypeInteger U8  = make(0,255);
+    public final static TypeInteger U16 = make(0,65535);
+    public final static TypeInteger U32 = make(0,(1L<<32)-1);
+
+    /**
+     * Describes an integer *range* - everything from min to max; both min and
+     * max are inclusive.  If min==max, this is a constant.
+     *
+     * If min <= max, this is a  below center (towards bottom).
+     * If min >  max, this is an above center (towards top).
+     */
+    public final long _min, _max;
+
+    private TypeInteger(long min, long max) { super(TINT); _min = min; _max = max; }
+    public static TypeInteger make(long lo, long hi) {  return new TypeInteger(lo,hi).intern();  }
+    public static TypeInteger make(boolean is_con, long con) {
+        return make(is_con ? con : (con==0 ? Long.MAX_VALUE : Long.MIN_VALUE),
+                    is_con ? con : (con==0 ? Long.MIN_VALUE : Long.MAX_VALUE));
+    }
+
+    public static TypeInteger constant(long con) { return make(true, con); }
+
+    public static void gather(ArrayList<Type> ts) { ts.add(ZERO); ts.add(BOT); ts.add(U1); ts.add(U8); }
+
+    // FIXME this display format is problematic
+    // In visualizer '#' gets prepended if its a constant
+    @Override
+    public StringBuilder print(StringBuilder sb) { return sb.append(str()); }
+
+    @Override public String str() {
+        if( this==TOP ) return "~int";
+        if( this==BOT ) return  "int";
+        if( this==BOOL) return ("bool");
+        if( this==I8  ) return ("i8");
+        if( this==I16 ) return ("i16");
+        if( this==I32 ) return ("i32");
+        if( this==U8  ) return ("u8");
+        if( this==U16 ) return ("u16");
+        if( this==U32 ) return ("u32");
+        if( isConstant() ) return ""+_min;
+        return "["+_min+"-"+_max+"]";
+    }
+
+    /**
+     * Display Type name in a format that's good for IR printer
+     */
+    @Override
+    public StringBuilder typeName(StringBuilder sb) {
+        if( this==TOP ) return sb.append("IntTop");
+        if( this==BOT ) return sb.append("IntBot");
+        return sb.append("Int");
+    }
+
+    @Override public boolean isHigh       () { return _min >  _max; }
+    @Override public boolean isHighOrConst() { return _min >= _max; }
+    @Override public boolean isConstant   () { return _min == _max; }
+
+    @Override public int log_size() {
+        if( this==I8  || this==U8 || this==BOOL ) return 0; // 1<<0 == 1 bytes
+        if( this==I16 || this==U16              ) return 1; // 1<<1 == 2 bytes
+        if( this==I32 || this==U32              ) return 2; // 1<<2 == 4 bytes
+        if( this==BOT                           ) return 3; // 1<<3 == 8 bytes
+        if( isHighOrConst() ) return 0;
+        throw Utils.TODO();
+    }
+
+    public long value() { assert isConstant(); return _min; }
+
+    // AND-mask of forced zeros.  e.g. unsigned types will return their mask;
+    // u8 will return 0xFF.  But also a range of 16-18 (0x10-0x12) will return
+    // 0x13 - no value in the range {16,17,18} will allow bit 0x04 to be set.
+    public long mask() {
+        if( isHigh() ) return 0;
+        if( isConstant() ) return _min;
+        //if( _min<0 ) return -1L;
+        //if( _max==Long.MAX_VALUE ) return -1L;
+        // Those bit positions which differ min to max
+        long x = _min ^ _max;
+        // Highest '1' bit in the differ set.  Since the range is from min to
+        // max, all values below here are possible.
+        long ff1 = Long.highestOneBit(x);
+        // Make a all-1's mask from ff1, and set over the same bits (either min
+        // or max is ok).
+        long mask = _min | (ff1-1) | ff1;
+        return mask;
+    }
+
+    @Override
+    public Type xmeet(Type other) {
+        // Invariant from caller: 'this' != 'other' and same class (TypeInteger)
+        TypeInteger i = (TypeInteger)other; // Contract
+        return make(Math.min(_min,i._min), Math.max(_max,i._max));
+    }
+
+    @Override public TypeInteger dual() { return make(_max,_min); }
+    @Override public TypeInteger glb() { return BOT; }
+    @Override public TypeInteger lub() { return TOP; }
+    @Override public TypeInteger makeInit() { return ZERO; }
+    @Override public TypeInteger makeZero() { return ZERO; }
+    @Override public TypeInteger nonZero() {
+        if( isHigh() ) return this;
+        if( _min==0 ) return make(1,Math.max(_max,1)); // specifically good on BOOL
+        if( _max==0 ) return make(_min,-1);
+        return this;
+    }
+    @Override int hash() { return (int)((_min ^ (_min>>32)) *(_max ^ (_max>>32))); }
+    @Override
+    public boolean eq( Type t ) {
+        TypeInteger i = (TypeInteger)t; // Contract
+        return _min==i._min && _max==i._max;
+    }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeMem.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeMem.java
new file mode 100644
index 00000000..6dcd401a
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeMem.java
@@ -0,0 +1,69 @@
+package com.seaofnodes.simple.type;
+
+import com.seaofnodes.simple.Utils;
+import java.lang.Long;
+import java.util.BitSet;
+import java.util.ArrayList;
+
+
+/**
+ * Represents a slice of memory corresponding to a set of aliases
+ */
+public class TypeMem extends Type {
+
+    // Which slice of memory?
+    //  0 means TOP, no slice.
+    // -1 means BOT, all memory.
+    //  N means slice#N.
+    public final int _alias;
+    public final Type _t;       // Memory contents, some scalar type
+
+    private TypeMem(int alias, Type t) { super(TMEM); _alias = alias; _t = t; }
+
+    public static TypeMem make(int alias, Type t) { return new TypeMem(alias,t).intern(); }
+    public static final TypeMem TOP = make(-1, Type.TOP   );
+    public static final TypeMem BOT = make(-1, Type.BOTTOM);
+
+    public static void gather(ArrayList<Type> ts) { ts.add(make(1,TypeInteger.ZERO)); ts.add(BOT); }
+
+    @Override
+    TypeMem xmeet(Type t) {
+        TypeMem that = (TypeMem) t; // Invariant: TypeMem and unequal
+        if( this==TOP ) return that;
+        if( that==TOP ) return this;
+        if( this==BOT ) return BOT;
+        if( that==BOT ) return BOT;
+        int alias = _alias==that._alias ? _alias : -1;
+        Type mt = _t.meet(that._t);
+        return make(alias,mt);
+    }
+
+    @Override
+    public Type dual() {
+        return make(_alias,_t.dual());
+    }
+
+    @Override public Type glb() { return make(_alias,_t.glb()); }
+    @Override public Type lub() { return make(_alias,_t.lub()); }
+
+    @Override
+    int hash() { return 9876543 + _alias + _t.hashCode(); }
+
+    @Override
+    boolean eq(Type t) {
+        TypeMem that = (TypeMem) t; // Invariant
+        return _alias == that._alias && _t == that._t;
+    }
+
+    @Override
+    public StringBuilder print(StringBuilder sb) {
+        if( this==BOT ) return sb.append("MemBot");
+        if( this==TOP ) return sb.append("MemTop");
+        sb.append("MEM#");
+        if( _alias== 0 ) return sb.append("TOP");
+        if( _alias==-1 ) return sb.append("BOT");
+        return _t.print(sb.append(_alias).append(":"));
+    }
+
+    @Override public String str() { return toString(); }
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
new file mode 100644
index 00000000..8ecc8031
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
@@ -0,0 +1,123 @@
+package com.seaofnodes.simple.type;
+
+import java.util.ArrayList;
+
+/**
+ * Represents a Pointer to memory.
+ *
+ * Null is generic pointer to non-existent memory.
+ * *void is a non-Null pointer to all possible refs, both structs and arrays.
+ * Pointers can be to specific struct and array types, or a union with Null.
+ * The distinguished *$BOT ptr represents union of *void and Null.
+ * The distinguished *$TOP ptr represents the dual of *$BOT.
+ */
+public class TypeMemPtr extends Type {
+    // A TypeMemPtr is pair (obj,nil)
+    // where obj is a TypeStruct, possibly TypeStruct.BOT
+    // where nil is an explicit null is allowed or not
+
+    // Examples:
+    // (Person,false) - a not-nil Person
+    // (Person,true ) - a Person or a nil
+    // (BOT   ,false) - a not-nil void* (unspecified struct)
+    // (TOP   ,true ) - a nil
+
+    public final TypeStruct _obj;
+    // Deep read-only access through this pointer; independent of slot finality.
+    public boolean _ro;
+
+    public final boolean _nil;
+
+    private TypeMemPtr(TypeStruct obj, boolean nil) {
+        super(TMEMPTR);
+        assert obj!=null;
+        _obj = obj;
+        _ro = obj==TypeStruct.BOT;
+        _nil = nil;
+    }
+    public static TypeMemPtr make(TypeStruct obj, boolean nil) { return new TypeMemPtr(obj, nil).intern(); }
+    public static TypeMemPtr make(TypeStruct obj) { return make(obj, false); }
+    public TypeMemPtr makeFrom(TypeStruct obj) { return obj==_obj ? this : make(obj, _nil).withAccess(_ro); }
+    public TypeMemPtr makeFrom(boolean nil) { return nil==_nil ? this : make(_obj, nil).withAccess(_ro); }
+    @Override public TypeMemPtr makeRO() { return withAccess(true); }
+    @Override public boolean isFinal() { return _ro; }
+
+    public TypeMemPtr withAccess(boolean ro) {
+        if( _ro==ro || (_obj==TypeStruct.TOP && _nil) ) return this;
+        TypeMemPtr ptr = new TypeMemPtr(_obj, _nil);
+        ptr._ro = ro;
+        return ptr.intern();
+    }
+
+    // Writable slots can load and store references, so their element access
+    // must agree in both directions. A read-only outer view can weaken access.
+    @Override public boolean accessISA(Type dst) {
+        if( !(dst instanceof TypeMemPtr ptr) ) return true;
+        if( _ro && !ptr._ro ) return false;
+        if( ptr._ro || _obj._fields==null || ptr._obj._fields==null || !_obj.isAry() || !ptr._obj.isAry() ) return true;
+        Type a = _obj._fields[1]._type, b = ptr._obj._fields[1]._type;
+        return a.accessISA(b) && b.accessISA(a);
+    }
+
+    // An abstract pointer, pointing to either a Struct or an Array.
+    // Can also be null or not.
+    public static final TypeMemPtr BOT = make(TypeStruct.BOT,true);
+    public static final TypeMemPtr TOP = BOT.dual();
+    // An abstract null (can be Struct or Array) or not-null C void*
+    public static final TypeMemPtr NULLPTR = make(TypeStruct.TOP,true);
+    public static final TypeMemPtr VOIDPTR = NULLPTR.dual(); // A bottom mix of not-null ptrs, like C's void* but not null
+
+    public static final TypeMemPtr TEST= make(TypeStruct.TEST,false);
+    public static void gather(ArrayList<Type> ts) { ts.add(NULLPTR); ts.add(BOT); ts.add(TEST); ts.add(TEST.makeRO()); }
+
+    @Override
+    Type xmeet(Type t) {
+        TypeMemPtr that = (TypeMemPtr) t;
+        return TypeMemPtr.make((TypeStruct)_obj.meet(that._obj), _nil | that._nil).withAccess(_ro | that._ro);
+    }
+
+    @Override
+    public TypeMemPtr dual() { return TypeMemPtr.make(_obj.dual(), !_nil).withAccess(!_ro); }
+
+    @Override public TypeMemPtr glb() { return make(_obj.glb(),true ).withAccess(true); }
+    @Override public TypeMemPtr lub() { return make(_obj.lub(),false); }
+    // Is forward-reference
+    @Override public boolean isFRef() { return _obj.isFRef(); }
+    @Override public Type makeInit() { return _nil ? NULLPTR : Type.TOP; }
+    @Override public Type makeZero() { return NULLPTR; }
+    @Override public Type nonZero() { return VOIDPTR; }
+
+    @Override public boolean isHigh() { return this==TOP; }
+    @Override public boolean isConstant() { return this==NULLPTR; }
+    @Override public boolean isHighOrConst() { return this==TOP || this==NULLPTR; }
+
+    @Override public int log_size() { return 2; } // (1<<2)==4-byte pointers
+
+    @Override
+    int hash() { return (_ro ? 8192 : 0) ^ _obj.hashCode() ^ (_nil ? 1024 : 0); }
+
+    @Override
+    boolean eq(Type t) {
+        TypeMemPtr ptr = (TypeMemPtr)t; // Invariant
+        return _ro==ptr._ro && _obj == ptr._obj  && _nil == ptr._nil;
+    }
+
+    // [void,name,MANY]*[,?]
+    @Override
+    public StringBuilder print(StringBuilder sb) {
+        if( this==BOT ) return sb.append("PtrBot");
+        if( this==TOP ) return sb.append("PtrTop");
+        if( this== NULLPTR) return sb.append("null");
+        if( this== VOIDPTR) return sb.append("*void");
+        return _obj.print(sb.append("*")).append(_nil ? "?" : "");
+    }
+
+    @Override public String str() {
+        if( this==BOT ) return "PtrBot";
+        if( this==TOP ) return "PtrTop";
+        if( this== NULLPTR) return "null";
+        if( this== VOIDPTR) return "*void";
+        return "*"+_obj.str()+(_nil ? "?" : "");
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeStruct.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
new file mode 100644
index 00000000..97664e3c
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
@@ -0,0 +1,262 @@
+package com.seaofnodes.simple.type;
+
+import com.seaofnodes.simple.Utils;
+import java.util.ArrayList;
+
+/**
+ * Represents a struct type.
+ */
+public class TypeStruct extends Type {
+
+    // A Struct has a name and a set of fields; the fields themselves have
+    // names, types and aliases.  The name has no semantic meaning, but is
+    // useful for debugging.  Briefly during parsing a Struct can be a
+    // forward-ref; in this case the _fields array is null.
+
+    // Its illegal to attempt to load a field from a forward-ref struct.
+
+    // Example: "int rez = new S.x; struct S { int x; } return rez;" // Error, S not defined
+    // Rewrite: "struct S { int x; } int rez = new S.x; return rez;" // Ok, no forward ref
+    //
+    // During the normal optimization run, struct types "bottom out" at further
+    // struct references, so we don't have to handle e.g. cyclic types.  The
+    // "bottom out" is again the forward-ref struct.
+    public final String _name;
+    public final Field[] _fields;
+
+    TypeStruct(String name, Field[] fields) {
+        super(TSTRUCT);
+        _name = name;
+        _fields = fields;
+    }
+
+    // All fields directly listed
+    public static TypeStruct make(String name, Field... fields) { return new TypeStruct(name, fields).intern(); }
+    public static final TypeStruct TOP = make("$TOP",new Field[0]);
+    public static final TypeStruct BOT = make("$BOT",new Field[0]);
+    public static final TypeStruct TEST = make("test",new Field[]{Field.TEST});
+    // Forward-ref version
+    public static TypeStruct makeFRef(String name) { return make(name, (Field[])null); }
+    // Make a read-only version
+    @Override public TypeStruct makeRO() {
+        if( isFinal() ) return this;
+        Field[] flds = new Field[_fields.length];
+        for( int i=0; i<flds.length; i++ )
+            flds[i] = _fields[i].makeRO();
+        return make(_name,flds);
+    }
+
+    // Array
+    public static TypeStruct makeAry(TypeInteger len, int lenAlias, Type body, int bodyAlias) {
+        assert !(body instanceof TypeMemPtr tmp && !tmp._nil);
+        return make("[" + body.str() + "]",
+                    Field.make("#" ,len , lenAlias,true ),
+                    Field.make("[]",body,bodyAlias,false));
+    }
+
+    // A pair of self-cyclic types
+    private static final TypeStruct S1F = makeFRef("S1");
+    private static final TypeStruct S2F = makeFRef("S2");
+    public  static final TypeStruct S1  = make("S1", Field.make("a", TypeInteger.BOT, -1, false), Field.make("s2",TypeMemPtr.make(S2F,false),-2, false) );
+    private static final TypeStruct S2  = make("S2", Field.make("b", TypeFloat  .BOT, -3, false), Field.make("s1",TypeMemPtr.make(S1F,false),-4, false) );
+
+    private static final TypeStruct ARY = makeAry(TypeInteger.BOT,-1,TypeFloat.BOT,-2);
+
+    public static void gather(ArrayList<Type> ts) { ts.add(TEST); ts.add(BOT); ts.add(S1); ts.add(S2); ts.add(ARY); }
+
+    // Find field index by name
+    public int find(String fname) {
+        for( int i=0; i<_fields.length; i++ )
+            if( _fields[i]._fname.equals(fname) )
+                return i;
+        return -1;
+    }
+    public Field field(String fname) {
+        int idx = find(fname);
+        return idx== -1 ? null : _fields[idx];
+    }
+
+    // Find field index by alias
+    public int findAlias( int alias ) {
+        for( int i=0; i<_fields.length; i++ )
+            if( _fields[i]._alias==alias )
+                return i;
+        return -1;
+    }
+
+
+    @Override
+    Type xmeet(Type t) {
+        TypeStruct that = (TypeStruct) t;
+        if( this==TOP ) return that;
+        if( that==TOP ) return this;
+        if( this==BOT ) return BOT;
+        if( that==BOT ) return BOT;
+
+        // Within the same compilation unit, struct names are unique.  If the
+        // names differ, its different structs.  Across many compilation units,
+        // structs with the same name but different field layouts can be
+        // interned... which begs the question:
+        // "What is the meet of structs from two different compilation units?"
+        // And the answer is: "don't ask".
+        if( !_name.equals(that._name) )
+            return BOT;         // It's a struct; that's about all we know
+        if( this._fields==null ) return that;
+        if( that._fields==null ) return this;
+        if( _fields.length != that._fields.length ) return BOT;
+        // Just do field meets
+        Field[] flds = new Field[_fields.length];
+        for( int i=0; i<_fields.length; i++ ) {
+            Field f0 = _fields[i], f1 = that._fields[i];
+            if( !f0._fname.equals(f1._fname) || f0._alias != f1._alias )
+                return BOT;
+            flds[i] = (Field)f0.meet(f1);
+        }
+        return make(_name,flds);
+    }
+
+    @Override
+    public TypeStruct dual() {
+        if( this==TOP ) return BOT;
+        if( this==BOT ) return TOP;
+        if( _fields == null ) return this;
+        Field[] flds = new Field[_fields.length];
+        for( int i=0; i<_fields.length; i++ )
+            flds[i] = _fields[i].dual();
+        return make(_name,flds);
+    }
+
+    // Keeps the same struct, but lower-bounds all fields.
+    @Override public TypeStruct glb() {
+        if( _glb() ) return this;
+        // Need to glb each field
+        Field[] flds = new Field[_fields.length];
+        for( int i=0; i<_fields.length; i++ )
+            flds[i] = _fields[i].glb();
+        return make(_name,flds);
+    }
+    private boolean _glb() {
+        if( _fields!=null )
+          for( Field f : _fields )
+              if( f.glb() != f )
+                 return false;
+        return true;
+    }
+    @Override public TypeStruct lub() {
+        if( _lub() ) return this;
+        // Need to glb each field
+        Field[] flds = new Field[_fields.length];
+        for( int i=0; i<_fields.length; i++ )
+            flds[i] = _fields[i].lub();
+        return make(_name,flds);
+    }
+    private boolean _lub() {
+        if( _fields!=null )
+          for( Field f : _fields )
+              if( f.lub() != f )
+                 return false;
+        return true;
+    }
+
+
+    // Is forward-reference
+    @Override public boolean isFRef() { return _fields==null; }
+    // All fields are final
+    @Override public boolean isFinal() {
+        if( _fields==null ) return true;
+        for( Field fld : _fields )
+            if( !fld.isFinal() )
+                return false;
+        return true;
+    }
+
+    @Override
+    boolean eq(Type t) {
+        TypeStruct ts = (TypeStruct)t; // Invariant
+        if( !_name.equals(ts._name) )
+            return false;
+        if( _fields == ts._fields ) return true;
+        if( _fields==null || ts._fields==null ) return false;
+        if( _fields.length!=ts._fields.length )
+            return false;
+        for( int i = 0; i < _fields.length; i++ )
+            if( _fields[i] != ts._fields[i] )
+                return false;
+        return true;
+    }
+
+    @Override
+    int hash() {
+        long hash = _name.hashCode();
+        if( _fields != null )
+            for( Field f : _fields )
+                hash = Utils.rot(hash,13) ^ f.hashCode();
+        return Utils.fold(hash);
+    }
+
+    @Override
+    public StringBuilder print(StringBuilder sb) {
+        if( this==BOT ) return sb.append("StructBot");
+        if( this==TOP ) return sb.append("StructTop");
+        sb.append(_name);
+        if( _fields == null ) return sb; // Forward reference struct, just print the name
+        sb.append(" {");
+        for( Field f : _fields )
+            f._type.print(sb).append(f._final ? " " : " !").append(f._fname).append("; ");
+        return sb.append("}");
+    }
+
+    @Override public String str() {
+        if( this==BOT ) return "StructBot";
+        if( this==TOP ) return "StructTop";
+        return _name;
+    }
+
+
+    public boolean isAry() { return _fields.length==2 && _fields[1]._fname.equals("[]"); }
+
+    public int aryBase() {
+        assert isAry();
+        if( _offs==null ) _offs = offsets();
+        return _offs[1];
+    }
+    public int aryScale() {
+        assert isAry();
+        return _fields[1]._type.log_size();
+    }
+
+
+    // Field offsets as packed byte offsets
+    private int[] _offs;  // Lazily computed and not part of the type semantics
+    public int offset(int idx) {
+        if( _offs==null ) _offs = offsets();
+        return _offs[idx];
+    }
+    private int[] offsets() {    // Field byte offsets
+        // Compute a layout for a collection of fields
+        assert _fields != null; // No forward refs
+        // Compute a layout
+        int[] cnts = new int[4]; // Count of fields at log field size
+        for( Field f : _fields )
+            cnts[f._type.log_size()]++; // Log size is 0(byte), 1(i16/u16), 2(i32/f32), 3(i64/dbl)
+        int off = 0, idx = 0; // Base common struct fields go here, e.g. Mark/Klass
+        // Compute offsets to the start of each power-of-2 aligned fields.
+        int[] offs = new int[4];
+        for( int i=3; i>=0; i-- ) {
+            offs[i] = off;
+            off += cnts[i]<<i;
+        }
+        // Assign offsets to all fields.
+        // Really a hidden radix sort.
+        _offs = new int[_fields.length+1];
+        for( Field f : _fields ) {
+            int log = f._type.log_size();
+            _offs[idx++] = offs[log]; // Field offset
+            offs[log] += 1<<log;      // Next field offset at same alignment
+            cnts[log]--;              // Count down, should be all zero at end
+        }
+        _offs[_fields.length] = (off+7)& ~7; // Round out to max alignment
+        return _offs;
+    }
+
+}
diff --git a/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeTuple.java b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeTuple.java
new file mode 100644
index 00000000..a34c64db
--- /dev/null
+++ b/chapter17b/src/main/java/com/seaofnodes/simple/type/TypeTuple.java
@@ -0,0 +1,95 @@
+package com.seaofnodes.simple.type;
+
+import java.util.ArrayList;
+
+public class TypeTuple extends Type {
+
+    public final Type[] _types;
+
+    private TypeTuple(Type[] types) { super(TTUPLE); _types = types; }
+    public  static TypeTuple make(Type... types) { return new TypeTuple(types).intern(); }
+
+    private static final TypeTuple TEST = make(TypeInteger.BOT,TypeMemPtr.TEST);
+    public  static final TypeTuple START = make(Type.CONTROL,TypeMem.TOP,TypeInteger.BOT);
+    public  static void gather(ArrayList<Type> ts) {  ts.add(TEST); ts.add(START); }
+
+    @Override
+    Type xmeet(Type other) {
+        TypeTuple tt = (TypeTuple)other;     // contract from xmeet
+        if( _types.length != tt._types.length )
+            return BOTTOM;
+        Type[] ts = new Type[_types.length];
+        for( int i=0; i<_types.length; i++ )
+            ts[i] = _types[i].meet(tt._types[i]);
+        return make(ts);
+    }
+
+    @Override public Type dual() {
+        Type[] ts = new Type[_types.length];
+        for( int i=0; i<_types.length; i++ )
+            ts[i] = _types[i].dual();
+        return make(ts);
+    }
+
+    @Override
+    public Type glb() {
+        Type[] ts = new Type[_types.length];
+        for( int i=0; i<_types.length; i++ )
+            ts[i] = _types[i].glb();
+        return make(ts);
+    }
+
+    @Override public StringBuilder print(StringBuilder sb) {
+        sb.append("[  ");
+        for( Type t : _types )
+            t.print(sb).append(", ");
+        sb.setLength(sb.length()-2);
+        sb.append("]");
+        return sb;
+    }
+
+    @Override public String str() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[  ");
+        for( Type t : _types )
+            sb.append(t.str()).append(", ");
+        sb.setLength(sb.length()-2);
+        return sb.append("]").toString();
+    }
+
+    /**
+     * Display Type name in a format that's good for IR printer
+     */
+    @Override
+    public StringBuilder typeName(StringBuilder sb) {
+        sb.append("[");
+        for( Type t : _types )
+            t.typeName(sb).append(",");
+        sb.setLength(sb.length()-1);
+        return sb.append("]");
+    }
+
+    public static final TypeTuple IF_BOTH    = make(new Type[]{Type. CONTROL,Type. CONTROL});
+    public static final TypeTuple IF_NEITHER = make(new Type[]{Type.XCONTROL,Type.XCONTROL});
+    public static final TypeTuple IF_TRUE    = make(new Type[]{Type. CONTROL,Type.XCONTROL});
+    public static final TypeTuple IF_FALSE   = make(new Type[]{Type.XCONTROL,Type. CONTROL});
+
+    @Override
+    int hash() {
+        int sum = 0;
+        for( Type type : _types ) sum ^= type.hashCode();
+        return sum;
+    }
+
+    @Override
+    boolean eq( Type t ) {
+        TypeTuple tt = (TypeTuple)t; // Contract
+        if( _types.length != tt._types.length ) return false;
+        for( int i=0; i<_types.length; i++ )
+            if( _types[i]!=tt._types[i] )
+                return false;
+        return true;
+    }
+
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/BrainFuckTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
new file mode 100644
index 00000000..154b74a2
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/BrainFuckTest.java
@@ -0,0 +1,72 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+import org.junit.Ignore;
+
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class BrainFuckTest {
+
+    @Test
+    public void testBrainfuck() {
+        var program = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.".getBytes(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(";");
+        }
+
+        Parser parser = new Parser(
+                encoded + """
+var 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( var 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( var d = 1; d > 0; ) {
+                command = program[++pc];
+                if (command == 91) d++;
+                if (command == 93) d--;
+            }
+        }
+    } else if (command == 93) {
+        if (data[d]) {
+            for( var d = 1; d > 0; ) {
+                command = program[--pc];
+                if (command == 93) d++;
+                if (command == 91) d--;
+            }
+        }
+    }
+}
+return output;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Hello World!\n", Evaluator.evaluate(stop, 0, 10000).toString());
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter01Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter01Test.java
new file mode 100644
index 00000000..f7524c17
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter01Test.java
@@ -0,0 +1,100 @@
+package com.seaofnodes.simple;
+
+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() {
+        Parser parser = new Parser("return 1;");
+        StopNode stop = parser.parse();
+        StartNode start = Parser.START;
+        ReturnNode ret = (ReturnNode)stop.in(0);
+
+        assertTrue(ret.ctrl() instanceof CProjNode);
+        Node expr = ret.expr();
+        if( expr instanceof ConstantNode con ) {
+            assertEquals(start,con.in(0));
+            assertEquals(TypeInteger.constant(1), con._type);
+        } else {
+            fail();
+        }
+    }
+
+    @Test
+    public void testZero() {
+        Parser parser = new Parser("return 0;");
+        parser.parse();
+        StartNode start = Parser.START;
+        for( Node use : start._outputs )
+            if( use instanceof ConstantNode con && con._type instanceof TypeInteger )
+                assertEquals(TypeInteger.constant(0),con._type);
+    }
+
+    @Test
+    public void testBad1() {
+        try {
+            new Parser("ret").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'ret'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBad2() {
+        try {
+            new Parser("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 Parser("return - -12;").parse().print());
+    }
+
+    @Test
+    public void testBad4() {
+        try {
+            new Parser("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 Parser("return -100;").parse().print());
+    }
+
+    @Test
+    public void testBad6() {
+        try {
+            new Parser("return100").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'return100'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBad7() {
+        try {
+            new Parser("return 1;}").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Syntax error, unexpected }",e.getMessage());
+        }
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter02Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter02Test.java
new file mode 100644
index 00000000..a6075b75
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter02Test.java
@@ -0,0 +1,60 @@
+package com.seaofnodes.simple;
+
+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() {
+        Parser parser = new Parser("return 1+2*3+-5;");
+        StopNode ret = parser.parse();
+        assertEquals("return 2;", ret.print());
+    }
+
+    @Test
+    public void testAddPeephole() {
+        Parser parser = new Parser("return 1+2;");
+        StopNode ret = parser.parse();
+        assertEquals("return 3;", ret.print());
+    }
+
+    @Test
+    public void testSubPeephole() {
+        Parser parser = new Parser("return 1-2;");
+        StopNode ret = parser.parse();
+        assertEquals("return -1;", ret.print());
+    }
+
+    @Test
+    public void testMulPeephole() {
+        Parser parser = new Parser("return 2*3;");
+        StopNode ret = parser.parse();
+        assertEquals("return 6;", ret.print());
+    }
+
+    @Test
+    public void testDivPeephole() {
+        Parser parser = new Parser("return 6/3;");
+        StopNode ret = parser.parse();
+        assertEquals("return 2;", ret.print());
+    }
+
+    @Test
+    public void testMinusPeephole() {
+        Parser parser = new Parser("return 6/-3;");
+        StopNode ret = parser.parse();
+        assertEquals("return -2;", ret.print());
+    }
+
+    @Test
+    public void testExample() {
+        Parser parser = new Parser("return 1+2*3+-5;");
+        StopNode ret = parser.parse();
+        assertEquals("return 2;", ret.print());
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter03Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter03Test.java
new file mode 100644
index 00000000..f06e5dcf
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter03Test.java
@@ -0,0 +1,69 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter03Test {
+
+    @Test
+    public void testVarDecl() {
+        Parser parser = new Parser("int a=1; return a;");
+        StopNode ret = parser.parse();
+        assertEquals("return 1;", ret.print());
+    }
+
+    @Test
+    public void testVarAdd() {
+        Parser parser = new Parser("int a=1; int b=2; return a+b;");
+        StopNode ret = parser.parse();
+        assertEquals("return 3;", ret.print());
+    }
+
+    @Test
+    public void testVarScope() {
+        Parser parser = new Parser("int a=1; int b=2; int c=0; { int b=3; c=a+b; } return c;");
+        StopNode ret = parser.parse();
+        assertEquals("return 4;", ret.print());
+    }
+
+    @Test
+    public void testVarDist() {
+        Parser parser = new Parser("int x0=1; int y0=2; int x1=3; int y1=4; return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1); ");
+        StopNode ret = parser.parse();
+        assertEquals("return 8;", ret.print());
+    }
+
+    @Test
+    public void testSelfAssign() {
+        try {
+            new Parser("int a=a; return a;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'a'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testRedeclareVar() {
+        try {
+            new Parser("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 Parser("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/chapter17b/src/test/java/com/seaofnodes/simple/Chapter04Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter04Test.java
new file mode 100644
index 00000000..36727a8f
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter04Test.java
@@ -0,0 +1,165 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter04Test {
+
+    @Test
+    public void testPeephole() {
+        Parser parser = new Parser("return 1+arg+2; ");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg+3);", ret.print());
+    }
+
+    @Test
+    public void testPeephole2() {
+        Parser parser = new Parser("return (1+arg)+2;");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg+3);", ret.print());
+    }
+
+    @Test
+    public void testAdd0() {
+        Parser parser = new Parser("return 0+arg;");
+        StopNode ret = parser.parse();
+        assertEquals("return arg;", ret.print());
+    }
+
+    @Test
+    public void testAddAddMul() {
+        Parser parser = new Parser("return arg+0+arg;");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg*2);", ret.print());
+    }
+
+    @Test
+    public void testPeephole3() {
+        Parser parser = new Parser("return 1+arg+2+arg+3; ");
+        StopNode ret = parser.parse();
+        assertEquals("return ((arg*2)+6);", ret.print());
+    }
+
+    @Test
+    public void testMul1() {
+        Parser parser = new Parser("return 1*arg;");
+        StopNode ret = parser.parse();
+        assertEquals("return arg;", ret.print());
+    }
+
+    @Test
+    public void testSub0() {
+        Parser parser = new Parser("return arg-0;");
+        StopNode ret = parser.parse();
+        assertEquals("return arg;", ret.print());
+    }
+
+    @Test
+    public void test0Sub() {
+        Parser parser = new Parser("return 0-arg;");
+        StopNode ret = parser.parse();
+        assertEquals("return (-arg);", ret.print());
+    }
+
+    @Test
+    public void testSubNeg() {
+        Parser parser = new Parser("return 3--arg;");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg+3);", ret.print());
+    }
+
+    @Test
+    public void testNegSub() {
+        Parser parser = new Parser("return -arg-3;");
+        StopNode ret = parser.parse();
+        assertEquals("return (-(arg+3));", ret.print());
+    }
+
+    @Test
+    public void testVarArg() {
+        Parser parser = new Parser("return arg; ");
+        StopNode stop = parser.parse();
+        ReturnNode ret = stop.ret();
+        assertTrue(ret.in(0) instanceof CProjNode);
+        assertTrue(ret.in(1) instanceof ProjNode);
+        assertEquals(1, ((ProjNode)ret.in(1))._idx);
+        assertTrue(ret.in(2) instanceof ProjNode);
+        assertEquals(2, ((ProjNode)ret.in(2))._idx);
+    }
+
+    @Test
+    public void testConstantArg() {
+        Parser parser = new Parser("return arg; ", TypeInteger.constant(2));
+        StopNode ret = parser.parse();
+        assertEquals("return 2;", ret.print());
+    }
+
+    @Test
+    public void testCompEq() {
+        Parser parser = new Parser("return 3==3; ");
+        StopNode ret = parser.parse();
+        assertEquals("return 1;", ret.print());
+    }
+
+    @Test
+    public void testCompEq2() {
+        Parser parser = new Parser("return 3==4; ");
+        StopNode ret = parser.parse();
+        assertEquals("return 0;", ret.print());
+    }
+
+    @Test
+    public void testCompNEq() {
+        Parser parser = new Parser("return 3!=3; ");
+        StopNode ret = parser.parse();
+        assertEquals("return 0;", ret.print());
+    }
+
+    @Test
+    public void testCompNEq2() {
+        Parser parser = new Parser("return 3!=4; ");
+        StopNode ret = parser.parse();
+        assertEquals("return 1;", ret.print());
+    }
+
+    @Test
+    public void testBug1() {
+        Parser parser = new Parser("int a=arg+1; int !b=a; b=1; return a+2; ");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg+3);", ret.print());
+    }
+
+    @Test
+    public void testBug2() {
+        Parser parser = new Parser("int !a=arg+1; a=a; return a; ");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg+1);", ret.print());
+    }
+
+    @Test
+    public void testBug3() {
+        try {
+            new Parser("inta=1; return a;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'inta'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testBug4() {
+        Parser parser = new Parser("return -arg;");
+        StopNode ret = parser.parse();
+        assertEquals("return (-arg);", ret.print());
+    }
+
+    @Test
+    public void testBug5() {
+        Parser parser = new Parser("return arg--2;");
+        StopNode ret = parser.parse();
+        assertEquals("return (arg--2);", ret.print());
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter05Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter05Test.java
new file mode 100644
index 00000000..7ea75f49
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter05Test.java
@@ -0,0 +1,227 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.TypeInteger;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter05Test {
+
+    @Test
+    public void testIfStmt() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+if (arg == 1)
+    a = arg+2;
+else {
+    a = arg-3;
+}
+return a;
+""");
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return Phi(Region,(arg+2),(arg-3));", ret.toString());
+    }
+
+    @Test
+    public void testTest() {
+        Parser parser = new Parser(
+"""
+int c = 3;
+int b = 2;
+if (arg == 1) {
+    b = 3;
+    c = 4;
+}
+return c;""", TypeInteger.BOT);
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return Phi(Region,4,3);", ret.toString());
+    }
+
+    @Test
+    public void testReturn2() {
+        Parser parser = new Parser(
+"""
+if( arg==1 )
+    return 3;
+else
+    return 4;
+""", TypeInteger.BOT);
+        StopNode stop = parser.parse();
+        assertEquals("Stop[ return 3; return 4; ]", stop.toString());
+    }
+
+    @Test
+    public void testIfMergeB() {
+        Parser parser = new Parser(
+"""
+int a=arg+1;
+int b=0;
+if( arg==1 )
+    b=a;
+else
+    b=a+1;
+return a+b;""");
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return ((arg*2)+Phi(Region,2,3));", ret.toString());
+    }
+
+    @Test
+    public void testIfMerge2() {
+        Parser parser = new Parser(
+"""
+int a=arg+1;
+int b=arg+2;
+if( arg==1 )
+    b=b+a;
+else
+    a=b+1;
+return a+b;""");
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return ((Phi(Region,(arg*2),arg)+arg)+Phi(Region,4,5));", ret.toString());
+    }
+
+    @Test
+    public void testMerge3() {
+        Parser parser = new Parser(
+"""
+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.BOT);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,Phi(Region,2,3),Phi(Region,4,5));", stop.toString());
+    }
+
+    @Test
+    public void testMerge4() {
+        Parser parser = new Parser(
+"""
+int a=0;
+int b=0;
+if( arg )
+    a=1;
+if( arg==0 )
+    b=2;
+return arg+a+b;
+""", TypeInteger.BOT);
+        StopNode stop = parser.parse();
+        assertEquals("return ((arg+Phi(Region,1,0))+Phi(Region,2,0));", stop.toString());
+    }
+
+    @Test
+    public void testMerge5() {
+        Parser parser = new Parser(
+"""
+int a=arg==2;
+if( arg==1 )
+{
+    a=arg==3;
+}
+return a;""");
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return (arg==Phi(Region,3,2));", ret.toString());
+    }
+
+    @Test
+    public void testMergeSameCon() {
+        Parser parser = new Parser(
+"""
+int a=arg;
+if( arg==1 )
+    a=3;
+else
+    a=3;
+return a;
+""");
+        StopNode ret = parser.parse();
+        assertEquals("return 3;", ret.toString());
+    }
+
+    @Test
+    public void testTrue() {
+      StopNode stop = new Parser("return true;").parse();
+      assertEquals("return 1;",stop.toString());
+    }
+
+    @Test
+    public void testHalfDef() {
+        try {
+            new Parser("if( arg==1 ) int b=2; return b;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Cannot define a new name on one arm of an if",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testHalfDef2() {
+        try {
+            new Parser("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 Parser("if(arg==2) int a=1; else int b=2; return a;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Cannot define a new name on one arm of an if",e.getMessage());
+        }
+    }
+
+
+    @Test
+    public void testBadNum() {
+        try {
+            new Parser("return 1-;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Syntax error, expected an identifier or expression: ;",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testKeyword1() {
+        try {
+            new Parser("int true=0; return true;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Expected an identifier, found 'true'",e.getMessage());
+        }
+    }
+
+    @Test
+    public void testKeyword2() {
+        try {
+            new Parser("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 Parser("int a=1; ififif(arg)inta=2;return a;").parse();
+            fail();
+        } catch( RuntimeException e ) {
+            assertEquals("Undefined name 'ififif'",e.getMessage());
+        }
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter06Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter06Test.java
new file mode 100644
index 00000000..50c0580d
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter06Test.java
@@ -0,0 +1,294 @@
+package com.seaofnodes.simple;
+
+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() {
+        Parser parser = new Parser(
+"""
+if( true ) return 2;
+return 1;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 2;", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testPeepholeRotate() {
+        Parser parser = new Parser(
+"""
+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
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+    }
+
+    @Test
+    public void testPeepholeCFG() {
+        Parser parser = new Parser(
+"""
+int a=1;
+if( true )
+  a=2;
+else
+  a=3;
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 2;", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testIfIf() {
+        Parser parser = new Parser(
+"""
+int a=1;
+if( arg!=1 )
+    a=2;
+else
+    a=3;
+int b=4;
+if( a==2 )
+    b=42;
+else
+    b=5;
+return b;""", TypeInteger.BOT);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,42,5);", stop.toString());
+    }
+
+    @Test
+    public void testIfArgIf() {
+        Parser parser = new Parser(
+"""
+int a=1;
+if( 1==1 )
+    a=2;
+else
+    a=3;
+int b=4;
+if( arg==2 )
+    b=a;
+else
+    b=5;
+return b;""", TypeInteger.BOT);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,2,5);", stop.toString());
+    }
+
+    @Test
+    public void testMerge3With2() {
+        Parser parser = new Parser(
+"""
+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));
+        StopNode stop = parser.parse();
+        assertEquals("return 5;", stop.toString());
+    }
+
+    @Test
+    public void testMerge3With1() {
+        Parser parser = new Parser(
+"""
+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));
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3;", stop.toString());
+    }
+
+    @Test
+    public void testMerge3Peephole() {
+        Parser parser = new Parser(
+"""
+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.BOT);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,3,Phi(Region,4,5));", stop.toString());
+    }
+
+    @Test
+    public void testMerge3Peephole1() {
+        Parser parser = new Parser(
+"""
+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));
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3;", stop.toString());
+    }
+
+    @Test
+    public void testMerge3Peephole3() {
+        Parser parser = new Parser(
+"""
+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));
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 4;", stop.toString());
+    }
+
+    @Test
+    public void testDemo1NonConst() {
+        Parser parser = new Parser("""
+int a = 0;
+int b = 1;
+if( arg ) {
+    a = 2;
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b;
+""");
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return Phi(Region,4,1);", ret.toString());
+    }
+
+
+    @Test
+    public void testDemo1True() {
+        Parser parser = new Parser("""
+int a = 0;
+int b = 1;
+if( arg ) {
+    a = 2;
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b;
+""", TypeInteger.constant(1));
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return 4;", ret.toString());
+    }
+
+    @Test
+    public void testDemo1False() {
+        Parser parser = new Parser("""
+int a = 0;
+int b = 1;
+if( arg ) {
+    a = 2;
+    if( arg ) { b = 2; }
+    else b = 3;
+}
+return a+b;
+""", TypeInteger.constant(0));
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return 1;", ret.toString());
+    }
+
+    @Test
+    public void testDemo2NonConst() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return (Phi(Region,Phi(Region,2,3),0)+Phi(Region,3,1));", ret.toString());
+    }
+
+
+    @Test
+    public void testDemo2True() {
+        Parser parser = new Parser("""
+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));
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return 6;", ret.toString());
+    }
+
+    @Test
+    public void testDemo2arg2() {
+        Parser parser = new Parser("""
+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));
+        StopNode ret = parser.parse().iterate();
+        assertEquals("return 5;", ret.toString());
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter07Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter07Test.java
new file mode 100644
index 00000000..ad3622c9
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter07Test.java
@@ -0,0 +1,221 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.*;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Chapter07Test {
+
+    @Test
+    public void testExample() {
+        Parser parser = new Parser(
+"""
+while(arg < 10) {
+    arg = arg + 1;
+}
+return arg;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return Phi(Loop,arg,(Phi_arg+1));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testRegression() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+if(arg){}else{
+    while(a < 10) {
+        a = a + 1;
+    }
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,1,Phi(Loop,1,(Phi_a+1)));", stop.toString());
+    }
+
+    @Test
+    public void testWhileNested() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,Phi(Loop,Phi_sum,(Phi_sum+Phi(Loop,0,(Phi_j+1)))));", stop.toString());
+    }
+
+    @Test
+    public void testWhileScope() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    if (a == 2) a = 3;
+    else b = 4;
+}
+return b;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return Phi(Loop,2,Phi(Region,Phi_b,4));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhileNestedIfAndInc() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,2,(Phi(Region,Phi_b,4)+1));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+
+    @Test
+    public void testWhile() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+while(a < 10) {
+    a = a + 1;
+    a = a + 2;
+}
+return a;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhilePeep() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+while(a < 10) {
+    a = a + 1;
+    a = a + 2;
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile2() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+while(arg) a = 2;
+return a;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return Phi(Loop,1,2);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile2Peep() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+while(arg) a = 2;
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,1,2);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile3() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile3Peep() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile4() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testWhile4Peep() {
+        Parser parser = new Parser(
+"""
+int a = 1;
+int b = 2;
+while(a < 10) {
+    int b = a + 1;
+    a = b + 2;
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,1,(Phi_a+3));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter08Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter08Test.java
new file mode 100644
index 00000000..bb3bd674
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter08Test.java
@@ -0,0 +1,208 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+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() {
+        Parser parser = new Parser(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        break;
+    if (arg == 6)
+        break;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,Phi(Region,Phi(Loop,arg,(Phi_arg+1)),Add),Add);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof RegionNode);
+        Assert.assertEquals(5L, Evaluator.evaluate(stop, 1));
+        Assert.assertEquals(10L, Evaluator.evaluate(stop, 6));
+    }
+
+
+    @Test
+    public void testEx5() {
+        Parser parser = new Parser(
+                """
+int a = 1;
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+    if (arg == 7)
+        continue;
+    a = a + 1;
+}
+return a;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,1,Phi(Region,Phi_a,(Phi_a+1)));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+
+    @Test
+    public void testEx4() {
+        Parser parser = new Parser(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+    if (arg == 6)
+        break;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,Phi(Loop,arg,(Phi_arg+1)),Add);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof RegionNode);
+    }
+
+    @Test
+    public void testEx3() {
+        Parser parser = new Parser(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 6)
+        break;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,Phi(Loop,arg,(Phi_arg+1)),Add);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof RegionNode);
+    }
+
+
+    @Test
+    public void testEx2() {
+        Parser parser = new Parser(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+    if (arg == 6)
+        continue;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,arg,(Phi_arg+1));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+
+    @Test
+    public void testEx1() {
+        Parser parser = new Parser(
+                """
+while(arg < 10) {
+    arg = arg + 1;
+    if (arg == 5)
+        continue;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,arg,(Phi_arg+1));", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode);
+    }
+
+    @Test
+    public void testRegress1() {
+        Parser parser = new Parser(
+                """
+while( arg < 10 ) {
+    int a = arg+2;
+    if( a > 4 )
+        break;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return arg;", stop.toString());
+    }
+
+    @Test
+    public void testRegress2() {
+        Parser parser = new Parser("if(1) return 0;  else while(arg>- -arg) arg=arg+1; return 0;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testBreakOutsideLoop() {
+        try {
+            new Parser("""
+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() {
+        Parser parser = new Parser("""
+while(arg < 10) {
+    break;
+}
+return arg;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return arg;", stop.toString());
+    }
+
+    @Test
+    public void testRegress4() {
+        Parser parser = new Parser("""
+int a = 1;
+while(arg < 10) {
+    a = a + 1;
+    if (arg > 2) {
+        int a = 17;
+        break;
+    }
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,Phi(Loop,1,(Phi_a+1)),Add);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof RegionNode);
+    }
+
+    @Test
+    public void testRegress5() {
+        Parser parser = new Parser("""
+int a = 1;
+while(1) {
+    a = a + 1;
+    if (a<10) continue;
+    break;
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (Phi(Loop,1,Add)+1);", stop.toString());
+        assertTrue(stop.ret().ctrl() instanceof CProjNode prj && prj._idx==1 );
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter09Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter09Test.java
new file mode 100644
index 00000000..c31afcd6
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter09Test.java
@@ -0,0 +1,301 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.*;
+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() {
+        Parser parser = new Parser("""
+int v0=0;
+arg=0;
+while(v0) {
+        while(1) if(arg*arg*0==0) {}
+                while(0) {}
+    arg=1;
+}
+return 0;
+                """);
+        StopNode stop = parser.parse().iterate();
+    }
+
+    @Test
+    public void testGVN1() {
+        Parser parser = new Parser(
+                """
+int x = arg + arg;
+if(arg < 10) {
+    return arg + arg;
+}
+else {
+    x = x + 1;
+}
+return x;
+                """);
+        StopNode stop = parser.parse();
+        assertEquals("Stop[ return (arg*2); return (Mul+1); ]", stop.toString());
+        Assert.assertEquals(2L, Evaluator.evaluate(stop, 1));
+        Assert.assertEquals(23L, Evaluator.evaluate(stop, 11));
+    }
+
+    @Test
+    public void testGVN2() {
+        Parser parser = new Parser(
+                """
+return arg*arg-arg*arg;
+                """);
+        StopNode stop = parser.parse();
+        assertEquals("return 0;", stop.toString());
+        Assert.assertEquals(0L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testWorklist1() {
+        Parser parser = new Parser(
+                """
+int step = 1;
+while (arg < 10) {
+    arg = arg + step + 1;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,arg,(Phi_arg+2));", stop.toString());
+        Assert.assertEquals(11L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testWorklist2() {
+        Parser parser = new Parser(
+                """
+int cond = 0;
+int one = 1;
+while (arg < 10) {
+    if (cond) one = 2;
+    arg = arg + one*3 + 1;
+}
+return arg;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,arg,(Phi_arg+4));", stop.toString());
+        Assert.assertEquals(13L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testWorklist3() {
+        Parser parser = new Parser(
+                """
+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;
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testRegionPeepBug() {
+        Parser parser = new Parser(
+                """
+int v0=0;
+int v1=0;
+while(v1+arg) {
+    arg=0;
+    int v2=v0;
+    while(arg+1) {}
+    v0=1;
+    v1=v2;
+}
+                """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Stop[ return 0; return 0; ]", stop.toString());
+    }
+
+    @Test
+    public void testWhile0() {
+        Parser parser = new Parser("while(0) continue; if(0) arg=0;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testWhile1() {
+        Parser parser = new Parser("""
+if(0) while(0) {
+    int arg=arg;
+    while(0) {}
+}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+
+    @Test
+    public void testPrecedence() {
+        Parser parser = new Parser("return 3-1+2;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 4;", stop.toString());
+    }
+
+    @Test
+    public void testSwap2() {
+        Parser parser = new Parser("return 1+(1+1);");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3;", stop.toString());
+    }
+
+
+    @Test
+    public void testFuzz0() {
+        Parser parser = new Parser("""
+int one = 1;
+int a = 0;
+int zero = 0;
+while(arg) {
+    a = -(one + a + 2);
+    arg = arg + 1;
+    one = one + zero;
+}
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(-(Phi_a+3)));", stop.toString());
+    }
+
+    @Test
+    public void testFuzz1() {
+        Parser parser = new Parser("""
+while(1) {}
+while(arg) break;
+while(arg) arg=0;
+arg=0;
+int v0=0!=0<-0;
+return -0+0+0;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+
+    @Test
+    public void testFuzz2() {
+        Parser parser = new Parser("return 0+-0;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testFuzz3() {
+        Parser parser = new Parser("int v0=0; while(0==69) while(v0) return 0;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testFuzz4() {
+        Parser parser = new Parser("""
+while(1) {
+    arg=0<=0;
+    if(1<0) while(arg==-0) arg=arg-arg;
+}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testFuzz5() {
+        Parser parser = new Parser("""
+{
+    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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testFuzz6() {
+        Parser parser = new Parser(
+"""
+int v0=0;
+while(0==1) while(v0)
+        v0=1+v0;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testFuzz7() {
+        Parser parser = new Parser("""
+while(1) {}
+int v0=0;
+while(v0)
+    {}
+int v1=0;
+while(1)
+        v1=1;
+return v1+v0;
+                                   """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testFuzz8() {
+        Parser parser = new Parser("while(arg) arg = arg - 1;  return arg;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @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/chapter17b/src/test/java/com/seaofnodes/simple/Chapter10Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter10Test.java
new file mode 100644
index 00000000..f634e421
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter10Test.java
@@ -0,0 +1,572 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.*;
+import java.util.BitSet;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter10Test {
+    @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 stop = new Parser(src).parse().iterate();
+            org.junit.Assert.assertTrue(body,
+                stop.ret().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;"
+        } ) {
+            StopNode stop = new Parser(NULLABLE_POINT_SOURCE+body).parse().iterate();
+            assertEquals(body,-1L,com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,0));
+            assertEquals(body,42L,com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,1));
+        }
+    }
+
+    @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 Parser(NULLABLE_POINT_SOURCE+body).parse().iterate();
+                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() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testStruct() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 2;", stop.toString());
+    }
+
+    @Test
+    public void testExample() {
+        Parser parser = new Parser("""
+struct Vector2D { int x; int y; };
+!Vector2D !v = new Vector2D;
+v.x = 1;
+if (arg)
+    v.y = 2;
+else
+    v.y = 3;
+return v;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Vector2D;", stop.toString());
+    }
+
+    @Test
+    public void testBug() {
+        Parser parser = new Parser("""
+struct s0 {
+    int v0;
+};
+s0? v1=null;
+int v3=v1.zAicm;
+""");
+        try { parser.parse();  fail(); }
+        catch( Exception e ) {  assertEquals("Accessing unknown field 'zAicm' from 'null'",e.getMessage());  }
+    }
+
+    @Test
+    public void testBug2() {
+        Parser parser = new Parser("""
+struct s0 { int v0; };
+arg=0+new s0.0;
+""");
+        try { parser.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Expected an identifier, found 'null'",e.getMessage()); }
+    }
+
+    @Test
+    public void testLoop() {
+        Parser parser = new Parser("""
+struct Bar { int a; };
+!Bar !bar = new Bar;
+while (arg) {
+    bar.a = bar.a + 2;
+    arg = arg + 1;
+}
+return bar.a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi_a+2));", stop.toString());
+    }
+
+    @Test
+    public void testIf() {
+        Parser parser = new Parser("""
+struct Bar { int a; };
+!Bar !bar = new Bar;
+if (arg) bar = null;
+bar.a = 1;
+return bar.a;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Type null is not of declared type *Bar",e.getMessage()); }
+    }
+
+    @Test
+    public void testIf2() {
+        Parser parser = new Parser("""
+struct Bar { int a; };
+!Bar? !bar = null;
+if (arg) bar = new Bar;
+bar.a = 1;
+return bar.a;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Might be null accessing 'a'",e.getMessage()); }
+    }
+
+    @Test
+    public void testIf3() {
+        Parser parser = new Parser("""
+struct Bar { int a; };
+Bar bar = null;
+if (arg) bar = null;
+bar.a = 1;
+return bar.a;
+""");
+        try { parser.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Type null is not of declared type *Bar", e.getMessage()); }
+    }
+
+    @Test
+    public void testIfOrNull() {
+        Parser parser = new Parser("""
+struct Bar { int a; };
+!Bar? !bar = new Bar;
+if (arg) bar = null;
+if( bar ) bar.a = 1;
+return bar;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,(*void)Phi(Region,null,Bar),null);", stop.toString());
+    }
+
+    @Test
+    public void testIfOrNull2() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,4,3);", stop.toString());
+    }
+
+    @Test
+    public void testWhileWithNullInside() {
+        Parser parser = new Parser("""
+struct s0 {int v0;};
+!s0? !v0 = new s0;
+int ret = 0;
+while(arg) {
+    ret = v0.v0;
+    v0 = null;
+    arg = arg - 1;
+}
+return ret;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) {
+            assertEquals("Might be null accessing 'v0'", e.getMessage()); }
+    }
+
+    @Test
+    public void testRedeclareStruct() {
+        Parser parser = new Parser("""
+struct s0 {
+    int v0;
+};
+s0? v1=new s0;
+!s0? !v1;
+v1=new s0;
+""");
+        try { parser.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Redefining name 'v1'", e.getMessage()); }
+    }
+
+    @Test
+    public void testIter() {
+        // Build and use an iterator
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi(Loop,0,(Phi_x+1))+Phi_sum));", stop.toString());
+    }
+
+
+    @Test
+    public void test1() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,s0,Phi(Region,s0,Phi_ret));", stop.toString());
+    }
+
+    @Test
+    public void test2() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,s0,Phi(Region,s0,Phi_ret));", stop.toString());
+    }
+
+
+    @Test
+    public void test3() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,s0,Phi(Region,s0,Phi_ret));", stop.toString());
+    }
+
+    @Test
+    public void testBug3() {
+        Parser parser = new Parser("""
+struct s0 { int f0; };
+return new s0;
+int v0=null.f0;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return s0;", stop.toString());
+        assertEquals("Obj<s0>{f0=0}", Evaluator.evaluate(stop, 0).toString());
+    }
+
+    @Test
+    public void testBug4() {
+        Parser parser = new Parser("""
+if(0) {
+    while(0) if(arg) continue;
+    int v0=0;
+    while(1) {
+        int arg=-arg;
+        v0=arg;
+    }
+}
+   """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testBug5() {
+        Parser parser = new Parser("""
+struct s0 {
+    int f0;
+};
+if(0) return 0;
+else return new s0;
+if(new s0.f0) return 0;
+    """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return s0;", stop.toString());
+    }
+
+    @Test
+    public void testBug6MissedWorklist() {
+        Parser parser = new Parser("""
+while(0) {}
+int v4=0;
+while(0<arg) {
+    v4=v4+1;
+    while(1) v4=-v4;
+    while(0) arg=-1;
+}
+return 0;
+    """);
+        StopNode stop = parser.parse().iterate();
+    }
+
+    @Test
+    public void testBug7() {
+        Parser parser = new Parser("""
+struct s0 {  int f0; };
+s0 v0 = new s0;
+while(v0.f0) {}
+s0 v1 = v0;
+return v1;
+    """);
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (const)s0;", stop.toString());
+    }
+
+
+    @Test
+    public void testBug8() {
+        Parser parser = new Parser("""
+int v2=0;
+while(0)
+while(0) {}
+{
+    {
+        {
+            int v36=0;
+            {
+                while(0) {
+                    {
+                        while(-v2) {
+                            {
+                                while(v36) {
+                                                while(v2) return 0;
+                                                break;
+                                }                            }
+                            if(-v2) break;
+                        }
+                    }
+                }
+            }
+        }    }
+}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testBug9() {
+        Parser parser = new Parser("""
+int v0=arg==0;
+while(v0) continue;
+return 0;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test public void testReadBeforeStores() {
+        var stop = new Parser("""
+            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;
+            """).parse().iterate();
+        assertEquals(1133L, com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,0));
+        assertEquals(2244L, com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,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 stop = new Parser(NESTED_MEMORY).parse().iterate();
+        for (int arg=0; arg<7; arg++) {
+            var obj = (com.seaofnodes.simple.evaluator.Evaluator.Obj)
+                com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,arg);
+            org.junit.Assert.assertArrayEquals(new Object[] {
+                5L+arg, 7L+arg*(arg+1)-(arg>=2 ? 2 : 0), 11L+2*arg-(arg>=2 ? 2 : 0)
+            }, obj.fields());
+        }
+    }
+
+    @Test public void testMemoryAtEarlyReturns() {
+        var stop = new Parser("""
+            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;
+            """).parse().iterate();
+        for (int arg=0; arg<2; arg++) {
+            var obj = (com.seaofnodes.simple.evaluator.Evaluator.Obj)
+                com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,arg);
+            org.junit.Assert.assertArrayEquals(arg==0 ? new Object[]{3L,17L,7L} : new Object[]{11L,5L,13L}, obj.fields());
+        }
+    }
+
+    @Test public void testKeepLoadsAtMerge() {
+        StopNode stop = new Parser("""
+            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;
+            """).parse().iterate();
+        // The one-step safety check stops at the memory aggregate.
+        assertEquals(2,countMemoryNodes(stop,LoadNode.class,new BitSet()));
+        assertEquals(-1L,Evaluator.evaluate(stop,-1));
+        assertEquals(1L,Evaluator.evaluate(stop,0));
+        assertEquals(3L,Evaluator.evaluate(stop,3));
+    }
+
+    @Test public void testDropStores() {
+        StopNode stop = new Parser("""
+            struct S { int x; };
+            !S !s = new S;
+            if (arg) s.x=arg+1; else s.x=arg+2;
+            return s;
+            """).parse().iterate();
+        assertEquals(1,countMemoryNodes(stop,StoreNode.class,new BitSet()));
+        assertEquals(2L,((Evaluator.Obj)Evaluator.evaluate(stop,0)).fields()[0]);
+        assertEquals(4L,((Evaluator.Obj)Evaluator.evaluate(stop,3)).fields()[0]);
+    }
+
+    @Test public void testKeepReadsBeforeWrites() {
+        StopNode stop = new Parser("""
+            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;
+            """).parse().iterate();
+        assertEquals(2,countMemoryNodes(stop,LoadNode.class,new BitSet()));
+        assertEquals(-1L,Evaluator.evaluate(stop,-1));
+        assertEquals(1L,Evaluator.evaluate(stop,0));
+        assertEquals(3L,Evaluator.evaluate(stop,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/chapter17b/src/test/java/com/seaofnodes/simple/Chapter11Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter11Test.java
new file mode 100644
index 00000000..60ff05d8
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter11Test.java
@@ -0,0 +1,64 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.evaluator.Evaluator;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Chapter11Test {
+    @Test public void testIndependentField() {
+        var stop = new Parser("""
+            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;
+            """).parse().iterate();
+        assertEquals("return 42;",stop.toString());
+        assertEquals(42L,Evaluator.evaluate(stop,5));
+        assertNull(stop.walk(n -> n instanceof LoadNode ? n : null));
+    }
+
+    @Test public void testParallelMemoryPhis() {
+        var stop = new Parser("""
+            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;
+            """).parse().iterate();
+        int[] phis = {0};
+        stop.walk(n -> {
+            if (n instanceof MemPhiNode) 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));
+            return null;
+        });
+        assertTrue(phis[0]>=3);
+        assertArrayEquals(new Object[]{1L,2L,3L},((Evaluator.Obj)Evaluator.evaluate(stop,4)).fields());
+    }
+
+    @Test public void testLateSliceWorklist() throws ReflectiveOperationException {
+        // 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 parser = new Parser(Chapter10Test.NESTED_MEMORY);
+            var field = IterPeeps.class.getDeclaredField("WORK");
+            field.setAccessible(true);
+            Object work = field.get(null);
+            field = work.getClass().getDeclaredField("_R");
+            field.setAccessible(true);
+            ((java.util.Random)field.get(work)).setSeed(seed);
+            var stop = parser.parse().iterate();
+            assertArrayEquals(new Object[]{9L,25L,17L},((Evaluator.Obj)Evaluator.evaluate(stop,4)).fields());
+        }
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter12Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter12Test.java
new file mode 100644
index 00000000..7e3b6843
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter12Test.java
@@ -0,0 +1,196 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter12Test {
+    @Test
+    public void testJig() {
+        Parser parser = new Parser(
+"""
+return 3.14;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testLinkedList0() {
+        Parser parser = new Parser(
+"""
+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 { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Might be null accessing 'i'",e.getMessage()); }
+    }
+
+    @Test
+    public void testLinkedList1() {
+        Parser parser = new Parser(
+"""
+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;
+}
+if( !head ) return 0;
+LLI? next = head.next;
+if( next==null ) return 1;
+return next.i;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Stop[ return 0; return 1; return .i; ]", stop.toString());
+        assertEquals(2L, Evaluator.evaluate(stop,  3));
+    }
+
+    @Test
+    public void testCoRecur() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 17;", stop.toString());
+    }
+
+    @Test
+    public void testNullRef0() {
+        Parser parser = new Parser(
+"""
+struct N { !N? !next; int i; };
+N n = new N;
+return n.next;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return null;", stop.toString());
+    }
+
+    @Test
+    public void testNullRef1() {
+        Parser parser = new Parser(
+"""
+struct M { int m; };
+struct N { !M !next; int i; };
+N n = new N { next = new M; };
+return n.next;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (const)M;", stop.toString());
+    }
+
+    @Test
+    public void testNullRef2() {
+        Parser parser = new Parser(
+"""
+struct M { int m; };
+struct N { !M !next; int i; };
+N n = new N { next = null; }
+return n.next;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Type null is not of declared type *M",e.getMessage()); }
+    }
+
+    @Test
+    public void testNullRef3() {
+        Parser parser = new Parser(
+"""
+struct N { !N? !next; int i; };
+!N !n = new N;
+n.i = 3.14;
+return n.i;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Type 3.14 is not of declared type int",e.getMessage()); }
+    }
+
+    @Test
+    public void testNullRef4() {
+        Parser parser = new Parser("-null-5/null-5;");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot 'Add' null",e.getMessage()); }
+    }
+
+    @Test public void testNullRef5() {
+        Parser parser = new Parser("return null+42;");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot 'Add' null",e.getMessage()); }
+    }
+
+    @Test
+    public void testEmpty() {
+        Parser parser = new Parser(
+"""
+struct S{};
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testForwardRef0() {
+        Parser parser = new Parser(
+"""
+struct S1 { !S2? !s; };
+return new S2;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Unknown struct type 'S2'",e.getMessage()); }
+    }
+
+    @Test
+    public void testForwardRef1() {
+        Parser parser = new Parser(
+"""
+struct S1 { !S2? !s; };
+struct S2 { int x; };
+return new S1.s=new S2;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return S2;", stop.toString());
+    }
+
+    @Test
+    public void testcheckNull() {
+        Parser parser = new Parser(
+"""
+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 { parser.parse().iterate();  fail(); }
+        catch( Exception e ) {  assertEquals("Might be null accessing 'i'",e.getMessage());  }
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter13Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter13Test.java
new file mode 100644
index 00000000..8f64701f
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter13Test.java
@@ -0,0 +1,554 @@
+package com.seaofnodes.simple;
+
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+
+
+import static org.junit.Assert.assertEquals;
+
+public class Chapter13Test {
+
+    // A placeholder test used to rapidly rotate through fuzzer produced issues
+    @Test
+    public void testFuzzer() {
+        Parser parser = new Parser(
+"""
+while(---- -arg) {
+    while(-arg) {
+        while(-----arg*---0) {
+                int N=--false==false<--arg;
+                while(N<-4==N) {
+                    N=N+N;
+                }
+            }
+        {
+            int kzEl_r7EYz=3*----0!=-arg<(37*--97!=0/arg==arg)<=-(--arg!=0);
+            while(kzEl_r7EYz<---1) {
+                kzEl_r7EYz=kzEl_r7EYz+kzEl_r7EYz*arg>=24;
+                if(7) continue;
+                kzEl_r7EYz=false;
+                if(-kzEl_r7EYz+arg<-3) continue;
+                else {
+                    while(kzEl_r7EYz) continue;
+                    arg=----3;
+                    kzEl_r7EYz=-(-----arg*1>-kzEl_r7EYz);
+                    int v2uF_4ba=9;
+                }
+            }
+        }
+        int pjcp7rv=arg;
+        {
+            int m2ya3=--arg-pjcp7rv;
+            while(m2ya3<-----pjcp7rv>=pjcp7rv+--pjcp7rv!=---pjcp7rv!=-arg<---(-m2ya3)>m2ya3<=-----true>14!=--m2ya3) {
+                m2ya3=m2ya3+-(--0<=false<pjcp7rv/arg<=-true);
+                while((--m2ya3)<--arg<-----arg*false!=arg<pjcp7rv*arg) {
+                    pjcp7rv=-3+-arg;
+                    break;
+                }
+                while(-3) {
+                    while(67+0-61) m2ya3=m2ya3;
+                    if(----pjcp7rv==---(---arg)) pjcp7rv=0!=-23;
+                    else pjcp7rv=----89;
+                    while(m2ya3!=m2ya3<pjcp7rv) m2ya3=1;
+                    while(--arg<=pjcp7rv) pjcp7rv=-32<=-m2ya3+62;
+                }
+                break;
+            }
+        }
+        {
+            int arg=-1<-9!=(-arg>=-pjcp7rv>=arg<=arg);
+            while(arg<-arg) {
+                arg=arg+--arg;
+                {
+                    while((--93)--pjcp7rv*-pjcp7rv+arg) arg=0-(6>=(--(---41/(0))!=--pjcp7rv)>=---2*33);
+                    pjcp7rv=11;
+                    int c=pjcp7rv;
+                    if(--107) break;
+                    else break;
+                }
+            }
+        }
+        pjcp7rv=pjcp7rv;
+        int aR0Wkua=-pjcp7rv==pjcp7rv;
+        {
+            if(-0!=-0) while(-true) break;
+            else {
+                while(aR0Wkua) pjcp7rv=-0/pjcp7rv;
+                pjcp7rv=pjcp7rv;
+            }
+        }
+    }
+    if(-arg) {
+        {
+            int Isdlt0fr91=0!=arg;
+            while(Isdlt0fr91<-Isdlt0fr91==-Isdlt0fr91+true) {
+                Isdlt0fr91=Isdlt0fr91+-1!=true;
+                if(-arg) if(--arg<=Isdlt0fr91) Isdlt0fr91=-Isdlt0fr91;
+                int i=---arg<---arg!=--40;
+                {
+                    int jVX43Ln4Dm=-(6)==-Isdlt0fr91/----0;
+                    while(jVX43Ln4Dm<--(3-3)) {
+                        jVX43Ln4Dm=jVX43Ln4Dm+-0<25;
+                        i=24<--(jVX43Ln4Dm);
+                    }
+                }
+                i=(arg!=----false>=7);
+                int Te=5>-arg;
+                break;
+            }
+        }
+        arg=arg!=--true/arg;
+        {
+            int UX=arg;
+            while(UX<-3*arg) {
+                UX=UX+arg/-1;
+                arg=-3--(-UX- -47<arg==--arg==arg)/arg- -UX>=-arg;
+                if(---12) while(-UX) break;
+                break;
+            }
+        }
+        continue;
+    }
+    if(arg) arg=--0;
+    else if(1) continue;
+    int DtTlhjYq=19==arg;
+    {
+        arg=--DtTlhjYq<=(DtTlhjYq/---DtTlhjYq<=-DtTlhjYq);
+        if(---arg) continue;
+        else {
+                int Zsl=40;
+                while(Zsl<--Zsl--false>((Zsl))==Zsl!=--DtTlhjYq-DtTlhjYq-DtTlhjYq) {
+                    Zsl=Zsl+arg;
+                }
+            }
+        if((arg)) if(-DtTlhjYq) {
+            }
+            else while(((2)==3*arg/DtTlhjYq)<=0==---arg) return false;
+        else {
+                int lwbF=arg>=0;
+                while(lwbF<57) {
+                    lwbF=lwbF+--(-arg+lwbF)>=-2>=arg!=arg;
+                    arg=----0+0;
+                    while(49) break;
+                    if(true) DtTlhjYq=-----arg;
+                    DtTlhjYq=0!=-----(0);
+                }
+            }
+        arg=---arg!=DtTlhjYq/--0;
+        DtTlhjYq=-DtTlhjYq/(--arg<arg);
+        if(32) {
+                int q=-DtTlhjYq;
+                while(q<arg*(0*q)/0) {
+                    q=q+DtTlhjYq;
+                    DtTlhjYq=arg;
+                }
+            }
+        else if(--arg) if(15) break;
+                else arg=0==arg<=-55>DtTlhjYq;
+            else {
+            }
+        DtTlhjYq=-0;
+        {
+            while((0)<-arg) DtTlhjYq=-DtTlhjYq;
+        }
+        if(30/--(arg)>=0) DtTlhjYq=-0>=arg;
+        else {
+            int Y2wcIQJ=--DtTlhjYq*---11;
+            if(arg==arg) {
+                Y2wcIQJ=-----Y2wcIQJ;
+                Y2wcIQJ=Y2wcIQJ<7;
+                if(DtTlhjYq) arg=arg;
+                else break;
+                while(-arg!=-31==(false<=-15>=-DtTlhjYq+--6*-----Y2wcIQJ<=---arg!=-Y2wcIQJ<=---0<-arg*--Y2wcIQJ)) DtTlhjYq=arg!=3;
+            }
+            continue;
+        }
+        arg=DtTlhjYq;
+        arg=--3/(---arg)>=80>=-DtTlhjYq<=DtTlhjYq;
+        arg=51+---(-true)!=arg!=----1==-DtTlhjYq;
+        if(11<=arg) if((arg)+79<32+(-arg)) continue;
+            else if(true==DtTlhjYq) break;
+        break;
+    }
+}
+if(arg!=62==arg) {
+    while(---arg) {
+        {
+            int bhmDacPM=arg/arg;
+            while(bhmDacPM<arg) {
+                bhmDacPM=bhmDacPM+80*((-bhmDacPM)/---bhmDacPM>1)<bhmDacPM-2!=7;
+                arg=-0;
+                arg=bhmDacPM>=-arg+-arg;
+                break;
+            }
+        }
+        int arg=true;
+        arg=arg<=arg;
+        {
+            int KlC=30;
+            while(KlC<-2) {
+                KlC=KlC+-1!=25<=-KlC>KlC>----0;
+                int Ij=arg>=-arg<=---10;
+                {
+                    int LAbgurVa2R=-arg!=Ij;
+                    while(LAbgurVa2R<-true) {
+                        LAbgurVa2R=LAbgurVa2R+Ij;
+                        KlC=-LAbgurVa2R;
+                        Ij=42*(-Ij>true);
+                        while(Ij) arg=KlC;
+                        KlC=-----7>-(--KlC<--7)==-LAbgurVa2R;
+                    }
+                }
+                int a=Ij<=-KlC;
+                if(Ij) {
+                    int r1W=a!=-false;
+                }
+                else {
+                    arg=56>=Ij;
+                    while(54) break;
+                    arg=8>=-(a<--Ij)/a>=-a-KlC;
+                }
+                int Yt_T=KlC;
+                arg=KlC;
+            }
+        }
+        if(----false/--arg/12+-----0) if(-9+-arg) while(arg!=(arg)) arg=--1>=-71-arg!=---(--arg*11+102)/--arg;
+            else if(----arg) continue;
+        if(-arg-arg) {
+            arg=-(-arg)*--(-3)<(-7==-arg----arg);
+            {
+                int arg=arg;
+                while(arg<-0>arg==-arg-(-arg>1+11)) {
+                    arg=arg+6-arg!=--0>---30>=---arg<=arg/(3)+---arg;
+                }
+            }
+            arg=-arg+arg;
+            arg=--47+-arg<1>arg*(-arg==-arg- -0>3);
+            arg=(----arg)!=arg+--59;
+            arg=- -4+arg==-(arg)-arg;
+        }
+        else {
+            while(--true-----true*-25+-18>arg>=-----(-arg)---13) {
+                arg=-0+--true<false;
+                continue;
+            }
+            arg=true<=arg;
+            break;
+        }
+        arg=arg*22<--(0+-arg);
+        {
+            continue;
+        }
+    }
+    arg=1*---((3<=true)==---2);
+    arg=7+-(-1);
+    return arg+--true;
+}
+else {
+    int o3ypEsewxM=-(---arg);
+    int vzXB=(-(---11<=--o3ypEsewxM>=--0))<=-0/-arg;
+    int L=-arg;
+    int B4mHcrf=---vzXB;
+    int oZWGdzZl=-o3ypEsewxM;
+    int K6tQqa1=11;
+    while(0!=--L) {
+            int sdZfTM=vzXB*true+K6tQqa1;
+            while(sdZfTM<false) {
+                sdZfTM=sdZfTM+arg;
+                sdZfTM=oZWGdzZl;
+                K6tQqa1=-K6tQqa1;
+                arg=---K6tQqa1;
+                while((3+-K6tQqa1)<oZWGdzZl) {
+                    if(-----(-1)) sdZfTM=-false;
+                    {}
+                }
+                K6tQqa1=vzXB!=-(B4mHcrf+-7>false);
+                sdZfTM=vzXB;
+            }
+        }
+    L=false;
+    while(31) B4mHcrf=arg;
+    oZWGdzZl=-0<--oZWGdzZl<=--2;
+    if(K6tQqa1>=20<=46) {
+        if(-1+-L) if(oZWGdzZl) {
+                int wmhv=-----0;
+            }
+        int arg=0;
+        o3ypEsewxM=---(oZWGdzZl);
+        return -oZWGdzZl/0;
+    }
+    else if(arg) {
+            int yKk5=B4mHcrf>=4>K6tQqa1<-B4mHcrf/o3ypEsewxM;
+            return -K6tQqa1;
+        }
+        else {
+            if(---0) {
+                {}
+                {}
+            }
+            return o3ypEsewxM;
+        }
+}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Stop[ return 9; return 0; return 0; return 0; return 0; ]", stop.toString());
+    }
+
+
+    @Test
+    public void testPrimes() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Stop[ return 0; return Phi(Loop,1,Phi(Region,Phi_primeCount,Phi(Region,(Phi_primeCount+1),Phi_primeCount))); ]", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  1)); // No primes 1 or below
+        assertEquals(1L, Evaluator.evaluate(stop,  2)); // 2
+        assertEquals(2L, Evaluator.evaluate(stop,  3)); // 2, 3
+        assertEquals(2L, Evaluator.evaluate(stop,  4)); // 2, 3
+        assertEquals(3L, Evaluator.evaluate(stop,  5)); // 2, 3, 5
+        assertEquals(4L, Evaluator.evaluate(stop, 10)); // 2, 3, 5, 7
+    }
+
+    @Test
+    public void testAntiDeps1() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 2;", stop.toString());
+        assertEquals(2L, Evaluator.evaluate(stop, 0));
+        assertEquals(2L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testAntiDeps2() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,.f,0);", stop.toString());
+    }
+
+    @Test
+    public void testAntiDeps3() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return S;", stop.toString());
+    }
+
+
+    @Test
+    public void testAntiDeps4() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return arg;", stop.toString());
+    }
+
+    @Test
+    public void testAntiDeps5() {
+        Parser parser = new Parser(
+"""
+struct S { int f; };
+!S !v = new S;
+while(1) {
+    while(arg+1) { arg=arg-1; }
+    if (arg) break;
+    v.f = 2;
+}
+return v;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return S;", stop.toString());
+    }
+
+    @Test
+    public void testAntiDeps6() {
+        Parser parser = new Parser(
+"""
+struct s { int v; };
+!s !ptr=new s;
+while( -arg )
+  ptr = new s;
+while(1)
+  arg = arg+ptr.v;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testAntiDeps7() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testAntiDeps8() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testAntiDeps9() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return S;", stop.toString());
+    }
+
+    @Test
+    public void testExample2() {
+        Parser parser = new Parser(
+"""
+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;
+                """);
+        StopNode stop = parser.parse().iterate();
+        //assertEquals("return new S;", stop.toString());
+    }
+
+    @Test
+    public void testScheduleUse() {
+        Parser parser = new Parser(
+"""
+int v0=0;
+while(0>=0) {
+    u1 v1=0;
+    v1=v0;
+    if(v1*0)
+        v0=-v1;
+}
+return 0;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testLoopCarriedDep() {
+        Parser parser = new Parser(
+"""
+u32 v0=0;
+{
+    int v1=0;
+    while(v1) {
+        v1=1>>>v0!=0;
+        v0=v1/0;
+    }
+}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter14FloatTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter14FloatTest.java
new file mode 100644
index 00000000..bff36f3a
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter14FloatTest.java
@@ -0,0 +1,83 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+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 testSubZeroFloat() {
+        var stop = new Parser("flt x = arg; return 0-x;").parse().iterate();
+        // Compare strings so +0.0 and -0.0 remain distinct.
+        assertEquals("0.0", Evaluator.evaluate(stop,0).toString());
+        assertEquals("-1.0", Evaluator.evaluate(stop,1).toString());
+    }
+
+    @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 stop = new Parser(src).parse().iterate();
+            assertEquals(src,test[1],com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,0).toString());
+        }
+    }
+
+
+    @Test
+    public void testJig() {
+        Parser parser = new Parser(
+"""
+return 3.14;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testFloat() {
+        Parser parser = new Parser(
+"""
+return 3.14;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testSquareRoot() {
+        Parser parser = new Parser(
+"""
+flt guess = arg;
+while( 1 ) {
+    flt next = (arg/guess + guess)/2;
+    if( next == guess ) break;
+    guess = next;
+}
+return guess;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,(flt)arg,(((ToFloat/Phi_guess)+Phi_guess)/2.0));", stop.toString());
+        assertEquals(3.0, Evaluator.evaluate(stop,  9));
+        assertEquals(1.414213562373095, Evaluator.evaluate(stop,  2));
+    }
+
+    @Test
+    public void testFPOps() {
+        Parser parser = new Parser(
+"""
+flt x = arg;
+return x+1==x;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return ((flt)arg==(ToFloat+1.0));", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop, 1));
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter14Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter14Test.java
new file mode 100644
index 00000000..364ddaf9
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter14Test.java
@@ -0,0 +1,227 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter14Test {
+
+    @Test
+    public void testJig() {
+        Parser parser = new Parser(
+"""
+return 3.14;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testRange() {
+        Parser parser = new Parser(
+"""
+int b;
+if( arg ) b=1; else b=0;
+int c = 99;
+if( b < 0 ) c = -1;
+if( b > 2 ) c =  1;
+return c;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 99;", stop.toString());
+        assertEquals(99L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testU8() {
+        Parser parser = new Parser(
+"""
+u8 b = 123;
+b = b + 456;// Truncate
+return b;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 67;", stop.toString());
+        assertEquals(67L, Evaluator.evaluate(stop,  0));
+    }
+
+
+    @Test
+    public void testU8While() {
+        Parser parser = new Parser(
+"""
+u8 b = 123;
+while( b ) b = b + 456;// Truncate
+return b;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testU1() {
+        Parser parser = new Parser(
+"""
+bool b = 123;
+b = b + 456;// Truncate
+u1 c = b;   // No more truncate needed
+return c;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testAnd() {
+        Parser parser = new Parser(
+"""
+int b = 123;
+b = b+456 & 31;                 // Precedence
+return b;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3;", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testRefLoad() {
+        Parser parser = new Parser(
+"""
+struct Foo { u1 b; };
+!Foo !f = new Foo;
+f.b = 123;
+return f.b;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testSigned() {
+        Parser parser = new Parser(
+"""
+i8 b = 255;                     // Chopped
+return b;                       // Sign extend
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return -1;", stop.toString());
+        assertEquals(-1L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testI8() {
+        Parser parser = new Parser(
+"""
+i8 b = arg;
+b = b + 1;// Truncate
+return b;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (((((arg<<56)>>56)+1)<<56)>>56);", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 0));
+        assertEquals(-128L, Evaluator.evaluate(stop, 127));
+    }
+
+    @Test
+    public void testMask() {
+        Parser parser = new Parser(
+"""
+u16 mask = (1<<16)-1;           // AND mask
+int c = 123456789 & mask;
+return c;                       //
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 52501;", stop.toString());
+        assertEquals(52501L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testOr() {
+        Parser parser = new Parser(
+"""
+return (arg | 123 ^ 456) >>> 1;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (((arg|123)^456)>>>1);", stop.toString());
+        assertEquals(217L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testMaskFloat() {
+        Parser parser = new Parser(
+"""
+flt f = arg;
+arg = f & 0;
+return arg;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot '&' FltBot",e.getMessage()); }
+    }
+
+    @Test
+    public void testCloneAnd() {
+        Parser parser = new Parser("""
+int v0=0;
+u32 v1 = 1&(1<<arg)&(1<<arg);
+while(arg) v1=-v0;
+while(v1) break;
+return v1;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,(((1<<arg)&1)&Shl),0);", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testAndHigh() {
+        Parser parser = new Parser("""
+int v0=0;
+if(0&0>>>0) {
+    while(0) {
+        u8 v1=0;
+        v0=0>>>0;
+        v1=arg;
+        while(v1+0) {}
+    }
+}
+return v0;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testTypes() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter15Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter15Test.java
new file mode 100644
index 00000000..068f8f42
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter15Test.java
@@ -0,0 +1,387 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+import org.junit.Ignore;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter15Test {
+
+    @Test
+    public void testJig() {
+        Parser parser = new Parser(
+"""
+return 3.14;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testCyclic() {
+        Parser parser = new Parser(
+"""
+struct C { !C? !l; };
+!C !c = new C;
+c.l = c;
+return c;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return C;", stop.toString());
+        assertEquals("Obj<C>@1{l=obj@1}", Evaluator.evaluate(stop,  0).toString());
+    }
+
+    @Test
+    public void testSafetyCheck() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return [u8];", stop.toString());
+        assertEquals("\u0001", Evaluator.evaluate(stop,  0).toString());
+    }
+
+    @Test
+    public void testBasic1() {
+        Parser parser = new Parser(
+"""
+int[] is = new int[2];
+return is[1];
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testBasic2() {
+        Parser parser = new Parser(
+"""
+int[] is = new int[2];
+int[] is2 = new int[2];
+return is[1];
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testBasic3() {
+        Parser parser = new Parser(
+"""
+int[] !a = new int[2];
+a[0] = 1;
+a[1] = 2;
+return a[0];
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testBasic4() {
+        Parser parser = new Parser(
+"""
+struct A { int i; };
+!A?[] !a = new !A?[2];
+return a;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return [*A?];", stop.toString());
+        assertEquals("Obj<[*A?]>{#=2,[]=[null,null]}", Evaluator.evaluate(stop, 0).toString());
+    }
+
+    @Test
+    public void testBasic5() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,1.2,Phi(Region,2.3,.y));", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop, 0));
+        assertEquals(1.2 , Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testBasic6() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Might be null accessing '[]'",e.getMessage()); }
+    }
+
+    @Test
+    public void testTree() {
+        Parser parser = new Parser(
+"""
+// 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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Tree;", stop.toString());
+        assertEquals("Obj<Tree>{_kids=Obj<[*Tree?]>{#=2,[]=[Obj<Tree>{_kids=null},null]}}", Evaluator.evaluate(stop,  0).toString());
+    }
+
+    @Test
+    public void testNestedStructAddMemProj() {
+        Parser parser = new Parser(
+"""
+struct S { int a; int[] !b; };
+return 0;
+""");
+        StopNode stop = parser.parse();
+        assertEquals("return 0;", stop.toString());
+    }
+
+    @Test
+    public void testRollingSum() {
+        Parser parser = new Parser(
+"""
+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
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (.[]+(.[]*1000));", stop.toString());
+        assertEquals(1006L, Evaluator.evaluate(stop,  4));
+    }
+
+    @Test
+    public void sieveOEratosthenes() {
+        Parser parser = new Parser(
+"""
+int[] !ary = new int[arg], !primes = new int[arg];
+int nprimes = 0, p=2;
+// Find primes while p^2 < arg
+while( p*p < arg ) {
+    // skip marked non-primes
+    while( ary[p]==1 ) p = p + 1;
+    // p is now a prime
+    primes[nprimes] = p;  nprimes = nprimes + 1;
+    // Mark out the rest non-primes
+    int i = p + p;
+    while( i < ary# ) {
+        ary[i] = 1;
+        i = i + p;
+    }
+    p = p + 1;
+}
+// Now just collect the remaining primes, no more marking
+while( p < arg ) {
+    if( ary[p] == 0 ) {
+        primes[nprimes] = p;  nprimes = nprimes + 1;
+    }
+    p = p + 1;
+}
+// Copy/shrink the result array
+int[] !rez = new int[nprimes];
+int j = 0;
+while( j < nprimes ) {
+    rez[j] = primes[j];
+    j = j + 1;
+}
+return rez;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return [int];", stop.toString());
+        Evaluator.Obj obj = (Evaluator.Obj)Evaluator.evaluate(stop, 20);
+        assertEquals("[int] {int #; int ![]; }",obj.struct().toString());
+        long nprimes = (Long)obj.fields()[0];
+        long[] primes = new long[]{2,3,5,7,11,13,17,19};
+        for( int i=0; i<nprimes; i++ )
+            assertEquals(primes[i],(long)(Long)obj.fields()[i+1]);
+    }
+
+    @Test
+    public void testNewNodeInit() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return ((flt).i+.f);", stop.toString());
+        assertEquals(0.0, Evaluator.evaluate(stop,  0));
+    }
+
+
+    @Test
+    public void testBad0() {
+        Parser parser = new Parser(
+"""
+return new flt;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot allocate a flt",e.getMessage()); }
+    }
+
+    @Test
+    public void testBad1() {
+        Parser parser = new Parser(
+"""
+int is = new int[2];
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Type *[int] is not of declared type int",e.getMessage()); }
+    }
+
+    @Test
+    public void testBad2() {
+        Parser parser = new Parser(
+"""
+int[] is = new int[3.14];
+return is[1];
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot allocate an array with length 3.14",e.getMessage()); }
+    }
+
+    @Test
+    public void testBad3() {
+        Parser parser = new Parser(
+"""
+int[] is = new int[arg];
+return is[1];
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  4));
+        try { Evaluator.evaluate(stop,0); }
+        catch( ArrayIndexOutOfBoundsException e ) { assertEquals("Array index 1 out of bounds for array length 0",e.getMessage()); }
+        try { Evaluator.evaluate(stop,-1); }
+        catch( NegativeArraySizeException e ) { assertEquals("-1",e.getMessage()); }
+    }
+
+    @Test
+    public void testProgress() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testSharpNot() {
+        Parser parser = new Parser(
+"""
+if(0>>0) {}
+while(0) {}
+u32 v7=0;
+int v8=0;
+while(0<--1>>>---(v7*0==v8)) {}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+
+
+    @Test
+    public void testProgress2() {
+        Parser parser = new Parser(
+"""
+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;
+            }
+        }
+}
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter16Test.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter16Test.java
new file mode 100644
index 00000000..ea6b7c52
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter16Test.java
@@ -0,0 +1,171 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter16Test {
+
+    @Test
+    public void testJig() {
+        Parser parser = new Parser(
+"""
+return 3.14;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
+    }
+
+
+    @Test
+    public void testMulti0() {
+        Parser parser = new Parser(
+"""
+int x, y;
+return x+y;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+    }
+    @Test
+    public void testMulti1() {
+        Parser parser = new Parser(
+"""
+int x=2, y=x+1;
+return x+y;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 5;", stop.toString());
+        assertEquals(5L, Evaluator.evaluate(stop,  0));
+    }
+
+
+    @Test
+    public void testConstruct0() {
+        Parser parser = new Parser("""
+struct X { int x=3; };
+X z = new X;
+return z.x;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3;", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testConstruct2() {
+        Parser parser = new Parser("""
+struct X { int x=3; };
+X z = new X { x = 4; };
+return z.x;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 4;", stop.toString());
+        assertEquals(4L, Evaluator.evaluate(stop,  0));
+    }
+
+
+    @Test
+    public void testLinkedList1() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Stop[ return 0; return 1; return .i; ]", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+        assertEquals(1L, Evaluator.evaluate(stop,  1));
+        assertEquals(2L, Evaluator.evaluate(stop,  3));
+    }
+
+    @Test
+    public void testLinkedList2() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("Stop[ return 0; return 1; return .i; ]", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop,  0));
+        assertEquals(1L, Evaluator.evaluate(stop,  1));
+        assertEquals(2L, Evaluator.evaluate(stop, 11));
+    }
+
+    @Test
+    public void testSquare() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Square;", stop.toString());
+        assertEquals("Obj<Square>{side=3.0,diag=1.7320508075688772}", Evaluator.evaluate(stop,  3).toString());
+        assertEquals("Obj<Square>{side=4.0,diag=2.0}", Evaluator.evaluate(stop, 4).toString());
+    }
+    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() {
+        StopNode stop = new Parser(CONSTRUCTOR_MEMORY).parse().iterate();
+        assertEquals(111249L,Evaluator.evaluate(stop,0));
+        assertEquals(222352L,Evaluator.evaluate(stop,1));
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter17aTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter17aTest.java
new file mode 100644
index 00000000..423eade0
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter17aTest.java
@@ -0,0 +1,107 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter17aTest {
+
+    @Test
+    public void testFinal1() {
+        Parser parser = new Parser(
+"""
+int x=2, y=3;
+if( arg ) { int x = y; x = x*x; y=x; } // Shadow final x
+return y;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,9,3);", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop, 0));
+        assertEquals(9L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testConstruct1() {
+        Parser parser = new Parser("""
+struct X { int ~x; };
+X z = new X { x=3; };
+return z.x;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 3;", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop,  0));
+    }
+
+    @Test
+    public void testStructFinal0() {
+        Parser parser = new Parser("""
+struct Point { int ~x, ~y; };
+Point p = new Point { x=3; y=4; };
+return p;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (const)Point;", stop.toString());
+        assertEquals("Obj<Point>{x=3,y=4}", Evaluator.evaluate(stop,  0).toString());
+    }
+
+    @Test
+    public void testStructFinal1() {
+        Parser parser = new Parser("""
+struct Point { int x=3, y=4; };
+Point p = new Point { x=5; y=6; };
+p.x++;
+return p;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test
+    public void testStructFinal2() {
+        Parser parser = new Parser("""
+struct Point { int x=3, y=4; };
+Point p = new Point;
+p.x++;
+return p;
+""");
+        try { parser.parse().iterate(); 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 Parser(src).parse().iterate(); 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() {
+        Parser parser = new Parser("""
+struct Point { val x=3; val y=4; };
+Point p = new Point;
+p.x++;
+return p;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot reassign final 'x'",e.getMessage()); }
+    }
+
+    @Test
+    public void testStructFinal5() {
+        Parser parser = new Parser("""
+struct Point { var x=3; var y=4; };
+!Point !p = new Point;
+p.x++;
+return p;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Point;", stop.toString());
+        assertEquals("Obj<Point>{x=4,y=4}", Evaluator.evaluate(stop,  0).toString());
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/Chapter17bTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter17bTest.java
new file mode 100644
index 00000000..976691fc
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/Chapter17bTest.java
@@ -0,0 +1,500 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.StopNode;
+import org.junit.Test;
+import org.junit.Ignore;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter17bTest {
+
+    @Test
+    public void testJig() {
+        Parser parser = new Parser("return 1;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop,  0));
+    }
+
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testInc0() {
+        Parser parser = new Parser("""
+return arg++;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return arg;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testInc1() {
+        Parser parser = new Parser("""
+return arg+++arg++;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return ((arg*2)+1);", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testInc2() {
+        Parser parser = new Parser("""
+//   -(arg--)-(arg--)
+return -arg---arg--;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (-((arg*2)+-1));", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testInc3() {
+        Parser parser = new Parser("""
+int[] !xs = new int[arg];
+xs[0]++;
+xs[1]++;
+return xs[0];
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 2));
+    }
+
+    @Test
+    public void testInc4() {
+        Parser parser = new Parser("""
+u8[] !xs = new u8[1];
+xs[0]--;
+return xs[0];
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 255;", stop.toString());
+        assertEquals(255L, Evaluator.evaluate(stop, 2));
+    }
+
+    @Test
+    public void testInc5() {
+        Parser parser = new Parser("""
+struct S { u16 x; };
+!S !s = new S;
+s.x--;
+return s.x;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 65535;", stop.toString());
+        assertEquals(65535L, Evaluator.evaluate(stop, 2));
+    }
+
+    @Test
+    public void testInc6() {
+        Parser parser = new Parser("return --arg;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return (arg+-1);", stop.toString());
+        assertEquals(-1L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testInc7() {
+        Parser parser = new Parser("u8 x=0; return --x;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 255;", stop.toString());
+        assertEquals(255L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testInc8() {
+        Parser parser = new Parser("int x; x+=2; return x+=3;");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 5;", stop.toString());
+        assertEquals(5L, Evaluator.evaluate(stop, 0));
+    }
+
+    // ---------------------------------------------------------------
+    @Test public void testVar0() {
+        Parser parser = new Parser("var d; return d;");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected =expression: ;",e.getMessage()); }
+    }
+
+    @Test public void testVar1() {
+        Parser parser = new Parser("val d; return d;");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected =expression: ;",e.getMessage()); }
+    }
+
+    @Test public void testVar2() {
+        Parser parser = new Parser("int x; x=3; x++; return x; // Ok, no initializer so x is mutable ");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 4;", stop.toString());
+        assertEquals(4L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test public void testVar3() {
+        Parser parser = new Parser("int x=3; x++; return x; // Ok, primitive so x is mutable despite initializer ");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 4;", stop.toString());
+        assertEquals(4L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test public void testVar4() {
+        Parser parser = new Parser("struct S{int x;}; !S !s; s=new S; s.x++; return s.x; // Ok, no initializer so x is mutable ");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test public void testVar5() {
+        Parser parser = new Parser("struct S{int x;}; !S !s; s=new S{x=3;}; s.x++; return s.x; // Ok, no initializer so x is mutable ");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 4;", stop.toString());
+        assertEquals(4L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test public void testVar6() {
+        Parser parser = new Parser("struct S{int x;}; S s=new S; s.x++; return s.x; // Error initializer so x is immutable ");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar7() {
+        Parser parser = new Parser("struct S{int x;}; S s=new S{x=3;}; s.x++; return s.x; // Error initializer so x is immutable ");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar8() {
+        Parser parser = new Parser("struct S{int x;}; !S !s=new S; s.x++; return s.x; // Ok, has '!' so s.x is mutable ");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test public void testVar9() {
+        Parser parser = new Parser("struct S{int x;}; var s=new S; s.x++; return s.x; // Ok, has var so s.x is mutable ");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 1;", stop.toString());
+        assertEquals(1L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test public void testVar10() {
+        Parser parser = new Parser("struct S{int x;}; ~S s=new S; s.x++; return s.x; // Error, has val so x is immutable ");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar11() {
+        Parser parser = new Parser("""
+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
+ """);
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot modify final field 'x'",e.getMessage()); }
+    }
+
+    @Test public void testVar12() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 45;", stop.toString());
+        assertEquals(45L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testVar13() {
+        Parser parser = new Parser("""
+int i,i++;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Redefining name 'i'",e.getMessage()); }
+    }
+
+
+    @Test
+    public void testVar14() {
+        Parser parser = new Parser("""
+struct B {};
+struct A { !B !b; };
+A x = new A {
+    return b; // read before init
+    b = new B;
+};
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Cannot read uninitialized field 'b'",e.getMessage()); }
+    }
+
+    @Test
+    public void testVar15() {
+        Parser parser = new Parser("""
+struct B {};
+struct A { !B !b; };
+return new A {
+    if (arg) b = new B; // Constructor ends with partial init of b
+}.b;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("'A' is not fully initialized, field 'b' needs to be set in a constructor",e.getMessage()); }
+    }
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testTrinary0() {
+        Parser parser = new Parser("""
+return arg ? 1 : 2;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,1,2);", stop.toString());
+        assertEquals(2L, Evaluator.evaluate(stop, 0));
+        assertEquals(1L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testTrinary1() {
+        Parser parser = new Parser("""
+return arg ? 0 : arg;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return 0;", stop.toString());
+        assertEquals(0L, Evaluator.evaluate(stop, 0));
+    }
+
+    @Test
+    public void testTrinary2() {
+        Parser parser = new Parser("""
+struct Bar { int x; };
+var b = arg ? new Bar : null;
+return b ? b.x++ + b.x++ : -1;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,1,-1);", stop.toString());
+        assertEquals(-1L, Evaluator.evaluate(stop, 0));
+        assertEquals( 1L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testTrinary3() {
+        Parser parser = new Parser("""
+struct Bar { int x; };
+var b = arg ? new Bar;
+return b ? b.x++ + b.x++ : -1;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,1,-1);", stop.toString());
+        assertEquals(-1L, Evaluator.evaluate(stop, 0));
+        assertEquals( 1L, Evaluator.evaluate(stop, 1));
+    }
+
+    @Test
+    public void testTrinary4() {
+        // This test case will benefit from an unzipping transformation
+        Parser parser = new Parser("""
+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"
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,Phi(Region,.x,.x),0);", stop.toString());
+        assertEquals( 0L, Evaluator.evaluate(stop, 0));
+        assertEquals( 1L, Evaluator.evaluate(stop, 1));
+        assertEquals( 2L, Evaluator.evaluate(stop, 2));
+    }
+
+    @Test
+    public void testTrinary5() {
+        Parser parser = new Parser("""
+flt f=arg?1:1.2;
+return f;   // missing widening
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Region,1.0,1.2);", stop.toString());
+        assertEquals(1.2, Evaluator.evaluate(stop,  0));
+    }
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testFor0() {
+        Parser parser = new Parser("""
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return sum;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop, 3));
+        assertEquals(45L, Evaluator.evaluate(stop, 10));
+    }
+    @Test
+    public void testFor1() {
+        Parser parser = new Parser("""
+int sum=0, i=0;
+for( ; i<arg; i++ )
+    sum += i;
+return sum;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop, 3));
+        assertEquals(45L, Evaluator.evaluate(stop, 10));
+    }
+    @Test
+    public void testFor2() {
+        Parser parser = new Parser("""
+int sum=0;
+for( int i=0; ; i++ ) {
+    if( i>=arg ) break;
+    sum += i;
+}
+return sum;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop, 3));
+        assertEquals(45L, Evaluator.evaluate(stop, 10));
+    }
+    @Test
+    public void testFor3() {
+        Parser parser = new Parser("""
+int sum=0;
+for( int i=0; i<arg; )
+    sum += i++;
+return sum;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi_sum+Phi(Loop,0,(Phi_i+1))));", stop.toString());
+        assertEquals(3L, Evaluator.evaluate(stop, 3));
+        assertEquals(45L, Evaluator.evaluate(stop, 10));
+    }
+    @Test
+    public void testFor4() {
+        Parser parser = new Parser("""
+int sum=0;
+for( int i=0; i<arg; i++ )
+    sum += i;
+return i;
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Undefined name 'i'",e.getMessage()); }
+    }
+    @Test
+    public void testFor5() {
+        Parser parser = new Parser("""
+for(;;arg++;) {}
+""");
+        try { parser.parse().iterate(); fail(); }
+        catch( Exception e ) { assertEquals("Syntax error, expected Unexpected code after expression: ;",e.getMessage()); }
+    }
+
+
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testForward0() {
+        Parser parser = new Parser("""
+struct A{
+    !B? !f1;
+    !B? !f2;
+};
+return new A;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return A;", stop.toString());
+        assertEquals("Obj<A>{f1=null,f2=null}", Evaluator.evaluate(stop).toString());
+    }
+
+    @Test
+    public void testForward1() {
+        Parser parser = new Parser("""
+struct A{
+    !B?[]? !nil_array_of_b;
+    !B?[]  not_array_of_b = new !B?[0];
+};
+return new A.not_array_of_b;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return [*B?];", stop.toString());
+        assertEquals("Obj<[*B?]>{#=0,[]=[]}", Evaluator.evaluate(stop).toString());
+    }
+
+    // ---------------------------------------------------------------
+    @Test
+    public void testLinkedList2() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return Phi(Loop,0,(Phi_sum+.i));", stop.toString());
+        assertEquals(45L, Evaluator.evaluate(stop, 10));
+    }
+
+    @Test
+    public void sieveOfEratosthenes() {
+        Parser parser = new Parser(
+"""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        assertEquals("return [int];", stop.toString());
+        Evaluator.Obj obj = (Evaluator.Obj)Evaluator.evaluate(stop, 20);
+        assertEquals("[int] {int #; int ![]; }",obj.struct().toString());
+        long nprimes = (Long)obj.fields()[0];
+        long[] primes = new long[]{2,3,5,7,11,13,17,19};
+        for( int i=0; i<nprimes; i++ )
+            assertEquals(primes[i],(long)(Long)obj.fields()[i+1]);
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/CompoundAssignmentTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/CompoundAssignmentTest.java
new file mode 100644
index 00000000..0fa4283b
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/CompoundAssignmentTest.java
@@ -0,0 +1,77 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.evaluator.Evaluator;
+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) {
+            assertEquals("Must report a language error", RuntimeException.class, e.getClass());
+            assertNotNull(e.getMessage());
+            assertFalse("Must report a language error: " + e, e.getMessage().contains("Not yet implemented"));
+        }
+    }
+
+    private static void check(String src, long arg, long expected) {
+        var stop = new Parser(src).parse().iterate();
+        assertEquals(src, Long.valueOf(expected), Evaluator.evaluate(stop, arg));
+    }
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/FuzzerWrap.java b/chapter17b/src/test/java/com/seaofnodes/simple/FuzzerWrap.java
new file mode 100644
index 00000000..2c98f405
--- /dev/null
+++ b/chapter17b/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/chapter17b/src/test/java/com/seaofnodes/simple/MutabilityTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/MutabilityTest.java
new file mode 100644
index 00000000..8f99a059
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/MutabilityTest.java
@@ -0,0 +1,63 @@
+package com.seaofnodes.simple;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class MutabilityTest {
+    private static void ok(String src, String result) {
+        var stop = new Parser(src).parse().iterate();
+        assertEquals(result,com.seaofnodes.simple.evaluator.Evaluator.evaluate(stop,0).toString());
+    }
+    private static void bad(String src) {
+        try {
+            new Parser(src).parse().iterate();
+        } 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")));
+            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 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/chapter17b/src/test/java/com/seaofnodes/simple/SchedulerTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/SchedulerTest.java
new file mode 100644
index 00000000..d8a22fd3
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/SchedulerTest.java
@@ -0,0 +1,73 @@
+package com.seaofnodes.simple;
+
+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 {
+
+    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() {
+        Parser parser = new Parser("""
+struct S {
+    int f;
+}
+!S !v=new S;
+v.f = 2;
+int i=v.f;
+if (arg) v.f=1;
+return i;
+""");
+        StopNode stop = parser.parse();//.iterate();
+        var eval = new Evaluator(stop);
+        assertEquals(2L, eval.evaluate(1, 10));
+    }
+
+    @Test
+    public void testStoreInIf() {
+        Parser parser = new Parser("""
+struct S {
+    int f;
+};
+!S !v0=new S;
+if(arg) v0.f=1;
+return v0;
+""");
+        StopNode stop = parser.parse().iterate();
+        var eval = new Evaluator(stop);
+        assertObj(eval.evaluate(0, 10), "S", 0L);
+        assertObj(eval.evaluate(1, 10), "S", 1L);
+    }
+
+    @Test
+    public void testStoreInIf2() {
+        Parser parser = new Parser("""
+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;
+""");
+        StopNode stop = parser.parse().iterate();
+        var eval = new Evaluator(stop);
+        assertEquals(2L, eval.evaluate(0, 10));
+        assertEquals(2L, eval.evaluate(1, 10));
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/TypeTest.java b/chapter17b/src/test/java/com/seaofnodes/simple/TypeTest.java
new file mode 100644
index 00000000..3fac1641
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/TypeTest.java
@@ -0,0 +1,157 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.type.*;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+public class TypeTest {
+
+    // Test basic properties and GLB
+    @Test
+    public void testTypeAdHoc() {
+        TypeStruct s1 = TypeStruct.make("s1", new Field[]{
+                Field.make("a", TypeInteger.BOT,-1, false),
+                Field.make("b", TypeInteger.BOT,-2, false) });
+        TypeStruct s2 = TypeStruct.make("s2", new Field[]{
+                Field.make("a", TypeInteger.BOT,-3, false),
+                Field.make("b", TypeInteger.BOT,-4, false) });
+        Assert.assertEquals(s1, s1.glb());
+        Assert.assertNotEquals(s1, s1.dual());
+        Assert.assertEquals(s1.makeRO(), s1.dual().glb());
+
+        TypeMem m1 = TypeMem.make(1,TypeInteger.ZERO);
+        TypeMem m2 = TypeMem.make(2,TypeInteger.U16);
+        TypeMem m3 = TypeMem.make(3,TypeFloat.BOT);
+        TypeMem m4 = TypeMem.make(4,TypeInteger.BOT);
+
+        Assert.assertNotEquals(m1, m2);
+        Assert.assertNotEquals(m2, m3);
+        Assert.assertNotEquals(m3, m4);
+
+        Assert.assertEquals(TypeStruct.BOT, s1.meet(s2));
+        Assert.assertEquals(TypeMem.make(-1,TypeInteger.U16), m1.meet(m2));
+        Assert.assertEquals(TypeMem   .BOT, m2.meet(m3));
+        Assert.assertEquals(TypeMem   .BOT, m3.meet(m4));
+
+        Assert.assertEquals(TypeMem.make(1,TypeInteger.BOT), m1.glb());
+        Assert.assertEquals(TypeMem.make(1,TypeInteger.ZERO), m1.dual());
+        Assert.assertEquals(m4.dual(), m4.glb().dual());
+
+        TypeMemPtr ptr1 = TypeMemPtr.make(s1);
+        Assert.assertEquals(s1, ptr1._obj);
+        TypeMemPtr ptr2 = TypeMemPtr.make(s2);
+        Assert.assertEquals(s2, ptr2._obj);
+
+        TypeMemPtr ptr1nil = TypeMemPtr.make(s1, true);
+        Assert.assertEquals(s1, ptr1nil._obj);
+        Assert.assertTrue(ptr1nil._nil);
+        Assert.assertFalse(ptr1nil._obj==null);
+        TypeMemPtr ptr2nil = TypeMemPtr.make(s2, true);
+        Assert.assertEquals(s2, ptr2nil._obj);
+
+        Assert.assertNotEquals(ptr1, ptr2);
+        Assert.assertNotEquals(ptr1, ptr1.glb());
+        Assert.assertEquals(ptr1nil.withAccess(true), ptr1.glb());
+
+        Assert.assertEquals(ptr1, ptr1.dual().dual());
+        Assert.assertEquals(ptr1.glb().makeFrom(s1.dual().glb()), ptr1.dual().glb());
+        Assert.assertEquals(TypeMemPtr.make(TypeStruct.BOT,true).withAccess(false), ptr1.meet(ptr2nil));
+        Assert.assertEquals(ptr1nil, ptr1.meet(TypeMemPtr.NULLPTR));
+
+        TypeMemPtr TOP = TypeMemPtr.TOP;
+        TypeMemPtr BOT = TypeMemPtr.make(TypeStruct.BOT,true );
+        TypeMemPtr PTR = TypeMemPtr.make(TypeStruct.BOT,false);
+        TypeMemPtr NULL = TypeMemPtr.NULLPTR;
+        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(TOP, NULL_join_ptr1);
+        Type NULL_join_PTR = PTR.join(NULL);
+        Assert.assertEquals(TOP, NULL_join_PTR);
+        Type ptr1_dual = ptr1.dual();
+        Type nullableptr1_dual = ptr1nil.dual();
+    }
+
+    // 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.S1.dual();
+        Type d1 = d0.dual();
+        assertSame(TypeStruct.S1,d1);
+    }
+
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java b/chapter17b/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
new file mode 100644
index 00000000..30af9895
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
@@ -0,0 +1,374 @@
+package com.seaofnodes.simple.evaluator;
+
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+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]._type;
+            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] = vall(alloc.in(3));
+        } else {
+            body = new Object[num = type._fields.length];
+            for (int i=0; i<num; i++)
+                body[i] = val(alloc.in(3+i));
+        }
+        return new Object[]{new Obj(type,body),MEMORY};
+    }
+
+    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();
+        throw new AssertionError("Not a double " + v);
+    }
+
+    private Object cons(ConstantNode cons) {
+        var type = cons.compute();
+        if (type instanceof TypeInteger i) return i.value();
+        if (type instanceof TypeFloat i) return i.value();
+        assert type instanceof TypeMemPtr;
+        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 ToFloatNode  cast  -> (double)vall(cast.in(1));
+            case LoadNode     load  -> load(load);
+            case StoreNode    store -> store(store);
+            case MemMergeNode merge -> MEMORY;
+            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 ReadOnlyNode ro    -> val(ro.in(1));
+            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)) break;
+                        phiCache.add(val(block.nodes()[i].in(exit)));
+                    }
+                    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/chapter17b/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java b/chapter17b/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java
new file mode 100644
index 00000000..afcc700f
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java
@@ -0,0 +1,596 @@
+package com.seaofnodes.simple.evaluator;
+
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.Type;
+
+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 {
+
+    private final HashMap<Node,ArrayList<NodeData>> readers = new HashMap<>();
+
+    /**
+     * 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;
+        }
+
+    }
+
+    /**
+     * 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 LoadNode l) {
+                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 = l.in(1);
+                for(var out : l.antiDeps()) {
+                    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 LoadNode)) {
+                        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);
+            }
+            var loads = readers.get(data.node);
+            if (loads != null)
+                for (var load : loads) decUsers(load);
+        }
+
+        // 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));
+        int depth = 0;
+        while (!queue.isEmpty()) {
+            var data = queue.pop();
+            var node = data.node;
+            assert node instanceof CFGNode;
+            BasicBlock block;
+            switch (node) {
+                case StartNode s:
+                    block = new BasicBlock(s, depth++);
+                    break;
+                case LoopNode l:
+                    block = new BasicBlock(l, depth++, d(l.in(1)).block);
+                    break;
+                case RegionNode r:
+                    var prev = new ArrayList<BasicBlock>();
+                    for(int i=1; i<r.nIns(); i++) {
+                        od(r.in(i)).ifPresent(d->prev.add(d.block));
+                    }
+                    block = new BasicBlock(r, depth++, prev.toArray(BasicBlock[]::new));
+                    break;
+                case IfNode i:
+                    block = d(i.in(0)).block;
+                    break;
+                case ReturnNode r:
+                    block = d(r.in(0)).block;
+                    break;
+                default:
+                    block = new BasicBlock(node, depth++, 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 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>();
+        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);
+            }
+        }
+        // Writes, including New behind an aggregate, schedule before their
+        // anti-dependent reads in this reverse scheduling pass.
+        for (var load : data.values())
+            if (load.node instanceof LoadNode l)
+                for (var use : l.antiDeps())
+                    if ((use instanceof StoreNode || use instanceof NewNode) && data.containsKey(use)) {
+                        load.users++;
+                        readers.computeIfAbsent(use,k->new ArrayList<>()).add(load);
+                    }
+    }
+
+    /**
+     * 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 Node findSingleCFGOut(Node node) {
+        if (node instanceof StartNode) {
+            for(var n:node._outputs) if (n instanceof CProjNode p && p._idx==0) return p;
+            return null;
+        }
+        assert node._outputs.stream().filter(x -> x instanceof CFGNode).limit(2).count()<=1;
+        for(var n:node._outputs) if(n instanceof CFGNode) return n;
+        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 Scheduler.Block schedule(StartNode start) {
+        var scheduler = new Scheduler();
+        scheduler.doMarkAlive(start);
+        scheduler.doBuildCTF(start);
+        scheduler.doSchedule();
+        return scheduler.build(start);
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
new file mode 100644
index 00000000..7dcb88e5
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
@@ -0,0 +1,199 @@
+package com.seaofnodes.simple.fuzzer;
+
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.evaluator.Evaluator;
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.node.StopNode;
+
+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 = 1000;
+
+    /**
+     * 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;
+        if (a instanceof Evaluator.Obj ea && b instanceof Evaluator.Obj eb) {
+            if (ea.struct() != eb.struct()) return true;
+            for(int i=0;i<ea.fields().length;i++) {
+                if (neq(ea.fields()[i], eb.fields()[i])) return true;
+            }
+            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(Evaluator e1, Evaluator e2, long in) {
+        var r1 = e1.evaluate(in, EVAL_TIMEOUT);
+        var r2 = e2.evaluate(in, EVAL_TIMEOUT);
+        if (r1 == Evaluator.Status.TIMEOUT || r2 == Evaluator.Status.TIMEOUT) return;
+        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) {
+        StopNode stop1;
+        try {
+            stop1 = FuzzerUtils.parse(script, 123);
+        } catch (RuntimeException e1) {
+            try {
+                FuzzerUtils.parse(script, 456);
+            } catch (RuntimeException e2) {
+                if (FuzzerUtils.isExceptionFromSameCause(e1, e2)) {
+                    if (!valid || e1.getClass() == RuntimeException.class) return;
+                } else {
+                    e1.addSuppressed(e2);
+                }
+            }
+            throw e1;
+        }
+        var stop2 = FuzzerUtils.parse(script, 456);
+        var e1 = new Evaluator(stop1);
+        var e2 = new Evaluator(stop2);
+        checkGraphs(e1, e2, 0);
+        checkGraphs(e1, e2, 1);
+        checkGraphs(e1, e2, 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 parser = new Parser(sb.toString());
+
+            var stop = parser.parse();
+            int parse_peeps= Node.ITER_CNT;
+            int parse_nops = Node.ITER_NOP_CNT;
+            double parse_nop_ratio = (double)parse_nops/parse_peeps;
+            int nids = Node.UID();
+            if( nids <= max_nids ) return max_nids;
+
+            double parse_peeps_per_node = (double)parse_peeps/nids;
+
+            stop.iterate();
+            int iter_peeps= Node.ITER_CNT;
+            int iter_nops = Node.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/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
new file mode 100644
index 00000000..f947a234
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
@@ -0,0 +1,142 @@
+package com.seaofnodes.simple.fuzzer;
+
+import com.seaofnodes.simple.IterPeeps;
+import com.seaofnodes.simple.Parser;
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.node.StopNode;
+
+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);
+    }
+
+    /**
+     * Copy of Node.WVISIST
+     * Used to clear as exceptions might happen in the walk and left this bitset not cleared
+     */
+    private static final BitSet NodeWalkVisit;
+    private static final java.util.Random WorkRandom;
+
+    /**
+     * Write access to Iterate.MID_ASSERT
+     * Exception could happen mid assert and left this at true. Used to reset to false prior to parsing.
+     */
+    private static final MethodHandle set_MID_ASSERT;
+
+    /**
+     * 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());
+
+    static {
+        try {
+            NodeWalkVisit = getFieldValue(Node.class, "WVISIT");
+            WorkRandom = getFieldValue(getFieldValue(IterPeeps.class, "WORK"), "_R");
+            set_MID_ASSERT = MethodHandles.lookup().unreflectSetter(getField( IterPeeps.class, "MID_ASSERT"));
+        } catch (Exception e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    /**
+     * 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 StopNode parse(String script, long workListSeed) {
+        var err = System.err;
+        var out = System.out;
+        try {
+            System.setErr(NULL_PRINT_STREAM);
+            System.setOut(NULL_PRINT_STREAM);
+            try {
+                set_MID_ASSERT.invokeExact(false);
+            } catch (Throwable e) {
+                throw rethrow(e);
+            }
+            var parser = new Parser(script);
+            WorkRandom.setSeed(workListSeed);
+            var stop = parser.parse();
+            return stop.iterate();
+        } finally {
+            NodeWalkVisit.clear();
+            System.setErr(err);
+            System.setOut(out);
+        }
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
new file mode 100644
index 00000000..3731b40c
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
@@ -0,0 +1,176 @@
+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("\\{((?:[^{}]|\\{})+)(?:\\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);
+        });
+    }
+
+}
diff --git a/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
new file mode 100644
index 00000000..183dcb84
--- /dev/null
+++ b/chapter17b/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
@@ -0,0 +1,882 @@
+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;
+
+/**
+ * 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_BINARY_EXPRESSIONS_PER_EXPRESSION = 10;
+    private static final int MAX_UNARY_EXPRESSIONS_PER_EXPRESSION = 6;
+    private static final int MAX_NAME_LENGTH = 10;
+    private static final int MAX_BLOCK_DEPTH = 4;
+    private static final int MAX_EXPRESSION_DEPTH = 10;
+    private static final int MAX_SUFFIX_RECURSIVE_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";
+    /**
+     * List of keywords not valid for identifiers.
+     */
+    private static final HashSet<String> KEYWORDS;
+
+    static {
+        try {
+            KEYWORDS = FuzzerUtils.getFieldValue(new Parser(""), "KEYWORDS");
+        } catch (Throwable e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    /**
+     * 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;
+    /**
+     * Binary operators.
+     */
+    private static final String[] BINARY_OP = {"==", "!=", "<", "<=", ">", ">=", "+", "-", "*", "/", "&", ">>", ">>>", "<<"};
+    /**
+     * Unary operators.
+     */
+    private static final String[] UNARY_OP = {"-"};
+
+    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 {
+        new Parser("", TypeInteger.BOT);
+        for( var e : Parser.defaultTypes().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;
+    /**
+     * The depth of expressions allowed.
+     */
+    private int exprDepth = MAX_EXPRESSION_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);
+        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);
+        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);
+        sb.append(";\n");
+        addVariable(name, TYPE_INT);
+        printIndentation().append("while(").append(name).append("<");
+        genExpression(TYPE_INT, true);
+        sb.append(") {\n");
+        indentation += INDENTATION;
+        depth--;
+        loopDepth++;
+        printIndentation().append(name).append("=").append(name).append("+");
+        genExpression(TYPE_INT, true);
+        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();
+        sb.append(generateInvalid() ? getRandomName() : declType(type)).append(" !").append(name);
+        if (!(type instanceof TypeNullable) || random.nextBoolean()) {
+            sb.append("=");
+            genExpression(type, true);
+        }
+        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);
+        sb.append(";");
+        return 0;
+    }
+
+    /**
+     * Generate a return statement.
+     * @return FLAG_STOP
+     */
+    public int genReturn() {
+        var type = getType();
+        sb.append("return ");
+        genExpression(type, true);
+        sb.append(";");
+        return FLAG_STOP;
+    }
+
+    /**
+     * Generate a binary expression.
+     * This method does not care about operator precedence.
+     */
+    public void genExpression(Type type, boolean change) {
+        if (change && generateInvalid()) type = getType();
+        if (!(type instanceof TypeInt) && type != TYPE_FLT) {
+            genUnary(type, false);
+            return;
+        }
+        var num = randLog(MAX_BINARY_EXPRESSIONS_PER_EXPRESSION);
+        while(num-->0) {
+            genUnary(type, false);
+            sb.append(BINARY_OP[random.nextInt(BINARY_OP.length)]);
+        }
+        genUnary(type, false);
+    }
+
+    /**
+     * Generate a unary expression.
+     */
+    public void genUnary(Type type, boolean change) {
+        if (change && generateInvalid()) type = getType();
+        if (!(type instanceof TypeInt) && type != TYPE_FLT) {
+            genSuffix(type, false);
+            return;
+        }
+        var num = randLog(MAX_UNARY_EXPRESSIONS_PER_EXPRESSION);
+        while(num-->0) {
+            sb.append(UNARY_OP[random.nextInt(UNARY_OP.length)]);
+        }
+        genSuffix(type, false);
+    }
+
+    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();
+    }
+
+    /**
+     * Generate
+     */
+    public void genSuffix(Type type, boolean change) {
+        genSuffixRecursive(type, change, MAX_SUFFIX_RECURSIVE_DEPTH);
+    }
+
+    public void genSuffixRecursive(Type type, boolean change, int depth) {
+        if (change && generateInvalid()) type = getType();
+        if (depth > 0 && random.nextBoolean()) {
+            if (generateInvalid()) {
+                var field = getRandomName();
+                var t = getType();
+                genSuffixRecursive(t, true, depth-1);
+                sb.append(".").append(field);
+                return;
+            } else {
+                var field = getField(type);
+                if (field != null) {
+                    genSuffixRecursive(field.struct, true, depth-1);
+                    sb.append(".").append(field.name);
+                    return;
+                }
+            }
+        }
+        genPrimary(type, false);
+    }
+
+    /**
+     * Generate a primary expression.
+     */
+    public void genPrimary(Type type, boolean change) {
+        if (change && generateInvalid()) type = getType();
+        var rand = random.nextInt(10);
+        if (rand == 0 && exprDepth != 0) {
+            sb.append("(");
+            exprDepth--;
+            genExpression(type, false);
+            exprDepth++;
+            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);
+    }
+
+}