Chapter 10: Structs and Memorylinear-chapter10

Co-authored-by: Thalia Archibald <thalia@archibald.dev>
Co-authored-by: Dibyendu Majumdar <mobile@majumdar.org.uk>
Co-authored-by: XmiliaH <45106915+XmiliaH@users.noreply.github.com>
Co-authored-by: XmiliaH <xmilia.hermit@gmail.com>
Co-authored-by: Robert Obkircher <robert.obkircher@gmail.com>

16 files changed, 1968 insertions, 157 deletions

diff --git a/src/test/java/com/seaofnodes/simple/Chapter01Test.java b/src/test/java/com/seaofnodes/simple/Chapter01Test.java
index 13b42f96..89882b2f 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter01Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter01Test.java
@@ -41,7 +41,7 @@ public class Chapter01Test {
             new Parser("ret").parse();
             fail();
         } catch( RuntimeException e ) {
-            assertEquals("Syntax error, expected =: ",e.getMessage());
+            assertEquals("Undefined name 'ret'",e.getMessage());
         }
     }
 
@@ -83,7 +83,7 @@ public class Chapter01Test {
             new Parser("return100").parse();
             fail();
         } catch( RuntimeException e ) {
-            assertEquals("Syntax error, expected =: ",e.getMessage());
+            assertEquals("Undefined name 'return100'",e.getMessage());
         }
     }
 
diff --git a/src/test/java/com/seaofnodes/simple/Chapter03Test.java b/src/test/java/com/seaofnodes/simple/Chapter03Test.java
index a243beb1..c76df903 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter03Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter03Test.java
@@ -40,7 +40,7 @@ public class Chapter03Test {
 
     @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);");
+        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());
     }
diff --git a/src/test/java/com/seaofnodes/simple/Chapter05Test.java b/src/test/java/com/seaofnodes/simple/Chapter05Test.java
index 6ad3af15..35e54fa9 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter05Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter05Test.java
@@ -22,7 +22,7 @@ else {
 
 return a;""");
         StopNode ret = parser.parse().iterate();
-        assertEquals("return Phi(Region17,(arg+2),(arg-3));", ret.toString());
+        assertEquals("return Phi(Region18,(arg+2),(arg-3));", ret.toString());
     }
 
     @Test
@@ -65,7 +65,7 @@ else
     b=a+1;
 return a+b;""");
         StopNode ret = parser.parse().iterate();
-        assertEquals("return ((arg*2)+Phi(Region20,2,3));", ret.toString());
+        assertEquals("return ((arg*2)+Phi(Region21,2,3));", ret.toString());
     }
 
     @Test
@@ -80,7 +80,7 @@ else
     a=b+1;
 return a+b;""");
         StopNode ret = parser.parse().iterate();
-        assertEquals("return ((Phi(Region31,(arg*2),arg)+arg)+Phi(Region,4,5));", ret.toString());
+        assertEquals("return ((Phi(Region32,(arg*2),arg)+arg)+Phi(Region,4,5));", ret.toString());
     }
 
     @Test
@@ -100,7 +100,7 @@ else
 return a;
 """, TypeInteger.BOT);
         StopNode stop = parser.parse().iterate();
-        assertEquals("return Phi(Region33,Phi(Region21,2,3),Phi(Region31,4,5));", stop.toString());
+        assertEquals("return Phi(Region36,Phi(Region22,2,3),Phi(Region34,4,5));", stop.toString());
     }
 
     @Test
@@ -116,7 +116,7 @@ if( arg==0 )
 return arg+a+b;
 """, TypeInteger.BOT);
         StopNode stop = parser.parse();
-        assertEquals("return ((arg+Phi(Region13,1,0))+Phi(Region22,2,0));", stop.toString());
+        assertEquals("return ((arg+Phi(Region13,1,0))+Phi(Region28,2,0));", stop.toString());
     }
 
     @Test
@@ -206,7 +206,7 @@ return a;""");
             new Parser("int a=1; ififif(arg)inta=2;return a;").parse();
             fail();
         } catch( RuntimeException e ) {
-            assertEquals("Syntax error, expected =: (",e.getMessage());
+            assertEquals("Undefined name 'ififif'",e.getMessage());
         }
     }
 
diff --git a/src/test/java/com/seaofnodes/simple/Chapter06Test.java b/src/test/java/com/seaofnodes/simple/Chapter06Test.java
index 054e96e8..097c2617 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter06Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter06Test.java
@@ -65,7 +65,7 @@ else
     b=5;
 return b;""", TypeInteger.BOT);
         StopNode stop = parser.parse().iterate();
-        assertEquals("return Phi(Region32,42,5);", stop.toString());
+        assertEquals("return Phi(Region37,42,5);", stop.toString());
     }
 
     @Test
@@ -84,7 +84,7 @@ else
     b=5;
 return b;""", TypeInteger.BOT);
         StopNode stop = parser.parse().iterate();
-        assertEquals("return Phi(Region29,2,5);", stop.toString());
+        assertEquals("return Phi(Region30,2,5);", stop.toString());
     }
 
     @Test
@@ -144,7 +144,7 @@ else
 return a;
 """, TypeInteger.BOT);
         StopNode stop = parser.parse().iterate();
-        assertEquals("return Phi(Region37,3,Phi(Region35,4,5));", stop.toString());
+        assertEquals("return Phi(Region41,3,Phi(Region39,4,5));", stop.toString());
     }
 
     @Test
@@ -251,7 +251,7 @@ if( arg ) {
 return a+b+c;
 """);
         StopNode ret = parser.parse().iterate();
-        assertEquals("return (Phi(Region35,Phi(Region22,2,3),0)+Phi(Region,3,1));", ret.toString());
+        assertEquals("return (Phi(Region36,Phi(Region23,2,3),0)+Phi(Region,3,1));", ret.toString());
     }
 
 
diff --git a/src/test/java/com/seaofnodes/simple/Chapter07Test.java b/src/test/java/com/seaofnodes/simple/Chapter07Test.java
index adf10471..de9d16f2 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter07Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter07Test.java
@@ -37,7 +37,7 @@ if(arg){}else{
 return a;
 """);
         StopNode stop = parser.parse().iterate();
-        assertEquals("return Phi(Region22,1,Phi(Loop11,1,(Phi_a+1)));", stop.toString());
+        assertEquals("return Phi(Region24,1,Phi(Loop13,1,(Phi_a+1)));", stop.toString());
     }
 
     @Test
@@ -74,7 +74,7 @@ return b;
 """);
         Node._disablePeephole = true;
         StopNode stop = parser.parse();
-        assertEquals("return Phi(Loop8,2,Phi(Region26,Phi_b,4));", stop.toString());
+        assertEquals("return Phi(Loop8,2,Phi(Region27,Phi_b,4));", stop.toString());
         assertTrue(stop.ret().ctrl() instanceof ProjNode);
         Node._disablePeephole = false;
     }
@@ -94,7 +94,7 @@ while(a < 10) {
 return b;
 """);
         StopNode stop = parser.parse().iterate();
-        assertEquals("return Phi(Loop8,2,(Phi(Region26,Phi_b,4)+1));", stop.toString());
+        assertEquals("return Phi(Loop8,2,(Phi(Region27,Phi_b,4)+1));", stop.toString());
         assertTrue(stop.ret().ctrl() instanceof ProjNode);
     }
 
diff --git a/src/test/java/com/seaofnodes/simple/Chapter08Test.java b/src/test/java/com/seaofnodes/simple/Chapter08Test.java
index cea6dd0f..6688d598 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter08Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter08Test.java
@@ -1,5 +1,6 @@
 package com.seaofnodes.simple;
 
+import com.seaofnodes.simple.evaluator.Evaluator;
 import com.seaofnodes.simple.node.*;
 import com.seaofnodes.simple.type.TypeInteger;
 import org.junit.Assert;
@@ -25,8 +26,8 @@ return arg;
         StopNode stop = parser.parse().iterate();
         assertEquals("return Phi(Region36,Phi(Region25,Phi(Loop6,arg,(Phi_arg+1)),Add),Add);", stop.toString());
         assertTrue(stop.ret().ctrl() instanceof RegionNode);
-        Assert.assertEquals(5, GraphEvaluator.evaluate(stop, 1));
-        Assert.assertEquals(10, GraphEvaluator.evaluate(stop, 6));
+        Assert.assertEquals(5L, Evaluator.evaluate(stop, 1));
+        Assert.assertEquals(10L, Evaluator.evaluate(stop, 6));
     }
 
 
diff --git a/src/test/java/com/seaofnodes/simple/Chapter09Test.java b/src/test/java/com/seaofnodes/simple/Chapter09Test.java
index 5567299a..048a58c7 100644
--- a/src/test/java/com/seaofnodes/simple/Chapter09Test.java
+++ b/src/test/java/com/seaofnodes/simple/Chapter09Test.java
@@ -1,5 +1,6 @@
 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;
@@ -43,8 +44,8 @@ return x;
                 """);
         StopNode stop = parser.parse();
         assertEquals("Stop[ return (arg*2); return (Mul+1); ]", stop.toString());
-        Assert.assertEquals(2, GraphEvaluator.evaluate(stop, 1));
-        Assert.assertEquals(23, GraphEvaluator.evaluate(stop, 11));
+        Assert.assertEquals(2L, Evaluator.evaluate(stop, 1));
+        Assert.assertEquals(23L, Evaluator.evaluate(stop, 11));
     }
 
     @Test
@@ -55,7 +56,7 @@ return arg*arg-arg*arg;
                 """);
         StopNode stop = parser.parse();
         assertEquals("return 0;", stop.toString());
-        Assert.assertEquals(0, GraphEvaluator.evaluate(stop, 1));
+        Assert.assertEquals(0L, Evaluator.evaluate(stop, 1));
     }
 
     @Test
@@ -70,7 +71,7 @@ return arg;
                 """);
         StopNode stop = parser.parse().iterate();
         assertEquals("return Phi(Loop7,arg,(Phi_arg+2));", stop.toString());
-        Assert.assertEquals(11, GraphEvaluator.evaluate(stop, 1));
+        Assert.assertEquals(11L, Evaluator.evaluate(stop, 1));
     }
 
     @Test
@@ -87,7 +88,7 @@ return arg;
                 """);
         StopNode stop = parser.parse().iterate();
         assertEquals("return Phi(Loop8,arg,(Phi_arg+4));", stop.toString());
-        Assert.assertEquals(13, GraphEvaluator.evaluate(stop, 1));
+        Assert.assertEquals(13L, Evaluator.evaluate(stop, 1));
     }
 
     @Test
diff --git a/src/test/java/com/seaofnodes/simple/Chapter10Test.java b/src/test/java/com/seaofnodes/simple/Chapter10Test.java
new file mode 100644
index 00000000..f2e7ca2c
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/Chapter10Test.java
@@ -0,0 +1,404 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.node.Node;
+import com.seaofnodes.simple.node.StopNode;
+import com.seaofnodes.simple.type.*;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class Chapter10Test {
+
+    @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 new 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(Loop10,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(Region15,null,new Bar);", 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(Region32,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(Loop14,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(Loop10,new s0,Phi(Region31,new 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(Loop13,new s0,Phi(Region32,new 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(Loop10,new s0,Phi(Region30,new s0,Phi_ret));", stop.toString());
+    }
+
+    @Test
+    public void testBug3() {
+        Parser parser = new Parser("""
+struct s0 {
+    int f0;
+}
+if(0>=0) return new s0;
+return new s0;
+int v0=null.f0;
+""");
+        try { parser.parse(); fail(); }
+        catch( Exception e ) { assertEquals("Accessing unknown field 'f0' from 'null'", e.getMessage()); }
+    }
+
+    @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("Stop[ ]", 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 new 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 new 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("Stop[ ]", 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());
+    }
+
+}
diff --git a/src/test/java/com/seaofnodes/simple/SchedulerTest.java b/src/test/java/com/seaofnodes/simple/SchedulerTest.java
new file mode 100644
index 00000000..5def2782
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/SchedulerTest.java
@@ -0,0 +1,74 @@
+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._disablePeephole = true;
+        StopNode stop = parser.parse(true);//.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/src/test/java/com/seaofnodes/simple/TypeTest.java b/src/test/java/com/seaofnodes/simple/TypeTest.java
new file mode 100644
index 00000000..f9c580cc
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/TypeTest.java
@@ -0,0 +1,145 @@
+package com.seaofnodes.simple;
+
+import com.seaofnodes.simple.type.*;
+import org.junit.Assert;
+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),
+                Field.make("b", TypeInteger.BOT) });
+        TypeStruct s2 = TypeStruct.make("s2", new Field[]{
+                Field.make("a", TypeInteger.BOT),
+                Field.make("b", TypeInteger.BOT) });
+        Assert.assertEquals(s1, s1.glb());
+        Assert.assertNotEquals(s1, s1.dual());
+        Assert.assertEquals(s1, s1.dual().glb());
+
+        TypeMem m1 = TypeMem.make(1);
+        TypeMem m2 = TypeMem.make(2);
+        TypeMem m3 = TypeMem.make(3);
+        TypeMem m4 = TypeMem.make(4);
+
+        Assert.assertNotEquals(m1, m2);
+        Assert.assertNotEquals(m2, m3);
+        Assert.assertNotEquals(m3, m4);
+
+        Assert.assertEquals(TypeStruct.BOT, s1.meet(s2));
+        Assert.assertEquals(TypeMem   .BOT, m1.meet(m2));
+        Assert.assertEquals(TypeMem   .BOT, m2.meet(m3));
+        Assert.assertEquals(TypeMem   .BOT, m3.meet(m4));
+
+        Assert.assertEquals(TypeMem.BOT, m1.glb());
+        Assert.assertEquals(m1, m1.dual());
+        Assert.assertEquals(TypeMem.TOP, m1.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, ptr1.glb());
+
+        Assert.assertEquals(ptr1, ptr1.dual().dual());
+        Assert.assertEquals(ptr1.glb(), ptr1.dual().glb());
+        Assert.assertEquals(TypeMemPtr.BOT, ptr1.meet(ptr2nil));
+        Assert.assertEquals(ptr1.glb(), ptr1.meet(TypeMemPtr.NULLPTR));
+
+        TypeMemPtr TOP = TypeMemPtr.TOP;
+        TypeMemPtr BOT = TypeMemPtr.BOT;
+        TypeMemPtr PTR = TypeMemPtr.VOIDPTR;
+        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, 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 ta = mt.dual().meet(t1.dual());
+        Type tb = mt.dual().meet(t0.dual());
+        assertSame(ta,t1.dual());
+        assertSame(tb,t0.dual());
+    }
+
+    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);
+    }
+
+}
diff --git a/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java b/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
new file mode 100644
index 00000000..3cf5c57b
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
@@ -0,0 +1,209 @@
+package com.seaofnodes.simple.evaluator;
+
+import com.seaofnodes.simple.Utils;
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.Field;
+import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeMemPtr;
+import com.seaofnodes.simple.type.TypeStruct;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Objects;
+
+public class Evaluator {
+
+    private static final Object MEMORY = new Object();
+
+    public record Obj(TypeStruct struct, Object[] fields) {
+        @Override
+        public String toString() {
+            var sb = new StringBuilder();
+            sb.append("Obj<").append(struct._name).append("> {");
+            for(int i=0; i<struct._fields.length; i++) {
+                sb.append("\n  ").append(struct._fields[i]._fname).append("=").append(fields[i]);
+            }
+            return sb.append("\n}").toString();
+        }
+    }
+
+    private static int getFieldIndex(TypeStruct struct, MemOpNode memop) {
+        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 Object alloc(NewNode alloc) {
+        var type = ((TypeMemPtr)alloc.compute())._obj;
+        return new Obj(type, new Object[type._fields.length]);
+    }
+
+    private Object load(LoadNode load) {
+        var from = (Obj)val(load.in(2));
+        var idx = getFieldIndex(from.struct, load);
+        return from.fields[idx];
+    }
+
+    private Object store(StoreNode store) {
+        var to = (Obj)val(store.in(2));
+        var val = val(store.in(3));
+        var idx = getFieldIndex(to.struct, store);
+        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 Object cons(ConstantNode cons) {
+        var type = cons.compute();
+        if (type instanceof TypeInteger 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 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 MinusNode    minus -> -vall(minus.in(1));
+            case MulNode      mul   -> vall(mul.in(1)) * vall(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 CastNode     cast  -> val(cast.in(1));
+            case LoadNode     load  -> load(load);
+            case StoreNode    store -> store(store);
+            case NewNode      alloc -> alloc(alloc);
+            case ProjNode     proj  -> ((Object[])val(proj.ctrl()))[proj._idx];
+            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] = parameter;
+        for(int i=2;i<s.length;i++) s[i] = MEMORY;
+        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.in(1));
+                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/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java b/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java
new file mode 100644
index 00000000..674d12f5
--- /dev/null
+++ b/src/test/java/com/seaofnodes/simple/evaluator/Scheduler.java
@@ -0,0 +1,592 @@
+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 {
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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.isCFG() || 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 : mem._outputs) {
+                    if (out instanceof PhiNode p) {
+                        var r = p.in(0);
+                        for (int i = 1; i < p.nIns(); i++) {
+                            if (p.in(i) == mem) optionalRefinePlacement(data, r.in(i));
+                        }
+                    } else if (!(out instanceof 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);
+            }
+            if (data.node instanceof StoreNode s) {
+                // Store nodes have anti-deps to load nodes.
+                // So decrease the uses of these loads when the store is placed.
+                for (var out: s.in(1)._outputs) {
+                    if (out instanceof LoadNode) od(out).ifPresent(this::decUsers);
+                }
+            }
+        }
+
+        // Now all nodes should be placed and have a block assigned
+        assert this.data.values().stream().noneMatch(d->d.block==null);
+    }
+
+    /**
+     * Decrement the not-yet-placed users of a block.
+     * @param data The node for which the users should be decremented.
+     */
+    private void decUsers(NodeData data) {
+        assert data.users > 0;
+        if (--data.users == 0) {
+            assert data.block != null;
+            assert isValid(data);
+
+            // When all users are gone this node can be scheduled.
+            scheduleQueue.push(data);
+        }
+    }
+
+    /**
+     * Update the placement of a node
+     * @param data The node to update
+     * @param block The block before which the node should happen.
+     */
+    private void update(NodeData data, BasicBlock block) {
+        assert block != null;
+        if (data.users == 0) {
+            assert isPinnedNode(data);
+            return;
+        }
+        refinePlacement(data, block);
+        decUsers(data);
+    }
+
+    /**
+     * Checks if a CFG node is ready to be placed. This is used for regions joining branches.
+     * @param node The CFG node to check
+     * @return true if all parents of a CFG node are placed.
+     */
+    private boolean isCFGNodeReady(Node node) {
+        if (node instanceof LoopNode l) {
+            assert d(l.in(1)).block != null;
+        } else if (node instanceof RegionNode r) {
+            for(int i=1; i<r.nIns(); i++) {
+                if (od(r.in(i)).map(d->d.block==null).orElse(false)) return false;
+            }
+        } else {
+            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.isCFG();
+            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.isCFG() && 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.isCFG() == cfg;
+        assert isNotXCtrl(node);
+        nd = new NodeData(node);
+        if (cfg) nd.users=0;
+        data.put(node, nd);
+        queue.push(nd);
+    }
+
+    /**
+     * Mark all alive nodes.
+     * First all CFG nodes are marked, then all other nodes.
+     * @param node THe start node.
+     */
+    private void doMarkAlive(Node node) {
+        var cfgQueue = new Stack<NodeData>();
+        var dataQueue = new Stack<NodeData>();
+        var mem = new Stack<NodeData>();
+        markAlive(cfgQueue, node, true);
+        // Mark all CFG nodes.
+        while (!cfgQueue.isEmpty()) {
+            var data = cfgQueue.pop();
+            node = data.node;
+            assert node.isCFG();
+            if (!(node instanceof ReturnNode)) {
+                for (var out : node._outputs) if (out.isCFG() && isNotXCtrl(out)) markAlive(cfgQueue, out, true);
+            }
+            for (var in : node._inputs) if(in!=null && !in.isCFG() && isNotXCtrl(in)) markAlive(dataQueue, in, false);
+        }
+        // Mark all other nodes.
+        while (!dataQueue.isEmpty()) {
+            var data = dataQueue.pop();
+            node = data.node;
+            assert !node.isCFG();
+            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.isCFG()) markAlive(dataQueue, in, false);
+            }
+            if (node instanceof StoreNode) mem.push(data);
+        }
+        // Handle store nodes and increase load with an anti-dep to the store.
+        while (!mem.isEmpty()) {
+            var data = mem.pop();
+            node = data.node;
+            for(var out:node.in(1)._outputs) {
+                if (out instanceof LoadNode) od(out).ifPresent(d->d.users++);
+            }
+        }
+    }
+
+    /**
+     * Helper function to append the nodes of a block to an array of nodes
+     * @param arr The array the nodes of a block should be appended to.
+     * @param node A potentially separator node
+     * @param block The block from which the nodes should be appended.
+     * @return The combined new array.
+     */
+    private static Node[] appendNodes(Node[] arr, Node node, BasicBlock block) {
+        var idx = arr.length;
+        arr = Arrays.copyOf(arr, arr.length+block.reverseSchedule.size()+(node==null?0:1));
+        if (node != null) arr[idx++] = node;
+        for(int i=block.reverseSchedule.size()-1;i>=0;i--) {
+            arr[idx++] = block.reverseSchedule.get(i);
+        }
+        return arr;
+    }
+
+    /**
+     * Find the CFG output of a node
+     * @param node The node
+     * @return THe CFG output of the node.
+     */
+    private static Node findSingleCFGOut(Node node) {
+        if (node instanceof StartNode) {
+            for(var n:node._outputs) if (n instanceof ProjNode p && p._idx==0) return p;
+            return null;
+        }
+        assert node._outputs.stream().filter(Node::isCFG).limit(2).count()<=1;
+        for(var n:node._outputs) if(n.isCFG()) 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.isCFG() && 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, Utils.find(r._inputs, 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 ProjNode 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/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java b/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
index 936fb41e..51e39cd0 100644
--- a/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
+++ b/src/test/java/com/seaofnodes/simple/fuzzer/Fuzzer.java
@@ -1,11 +1,12 @@
 package com.seaofnodes.simple.fuzzer;
 
-import com.seaofnodes.simple.GraphEvaluator;
 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;
 
@@ -36,13 +37,15 @@ public class Fuzzer {
      * @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) {
+    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 =========");
@@ -51,20 +54,30 @@ public class Fuzzer {
         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 stop1 Stop node of the first graph
-     * @param stop2 Stop node of the second graph
+     * @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(StopNode stop1, StopNode stop2, long in) {
-        var e1 = GraphEvaluator.evaluateWithResult(stop1, in, EVAL_TIMEOUT);
-        var e2 = GraphEvaluator.evaluateWithResult(stop2, in, EVAL_TIMEOUT);
-        if (e1.type() == GraphEvaluator.ResultType.TIMEOUT || e2.type() == GraphEvaluator.ResultType.TIMEOUT) return;
-        if (e1.type() != e2.type())
-            throw new RuntimeException("Different calculations types " + e1.type() + " vs " + e2.type());
-        if (e1.value() != e2.value())
-            throw new RuntimeException("Different calculations values " + e1.value() + " vs " + e2.value());
+    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);
     }
 
     /**
@@ -91,9 +104,11 @@ public class Fuzzer {
             throw e1;
         }
         var stop2 = FuzzerUtils.parse(script, true);
-        checkGraphs(stop1, stop2, 0);
-        checkGraphs(stop1, stop2, 1);
-        checkGraphs(stop1, stop2, 10);
+        var e1 = new Evaluator(stop1);
+        var e2 = new Evaluator(stop2);
+        checkGraphs(e1, e2, 0);
+        checkGraphs(e1, e2, 1);
+        checkGraphs(e1, e2, 10);
     }
 
     /**
@@ -101,11 +116,11 @@ public class Fuzzer {
      * @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) {
+    private void check(String script, boolean valid, long seed) {
         try {
             runCheck(script, valid);
         } catch (Throwable e) {
-            recordException(e, script, s->runCheck(s, valid));
+            recordException(e, script, s->runCheck(s, valid), seed);
         }
     }
 
@@ -155,8 +170,8 @@ public class Fuzzer {
     public void fuzzPeeps(long seed) {
         var rand = new Random(seed);
         var sb = new StringBuilder();
-        var valid = new ScriptGenerator(rand, sb, false).genProgram();
-        check(sb.toString(), valid);
+        var valid = new ScriptGenerator(rand, sb, true).genProgram();
+        check(sb.toString(), valid, seed);
     }
 
 
diff --git a/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java b/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
index f13a51e1..18ef069a 100644
--- a/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
+++ b/src/test/java/com/seaofnodes/simple/fuzzer/FuzzerUtils.java
@@ -18,7 +18,7 @@ import java.util.BitSet;
 class FuzzerUtils {
 
     /**
-     * Get the value of a private field
+     * Get the val of a private field
      */
     @SuppressWarnings("unchecked")
     public static <T> T getFieldValue(Object obj, String name) throws NoSuchFieldException, IllegalAccessException {
@@ -74,10 +74,12 @@ class FuzzerUtils {
     }
 
     /**
-     * Check that eiter one of the objects is null or that both are equal.
+     * Check that the messages are similar.
      */
-    private static boolean equalOrNull(Object a, Object b) {
+    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);
     }
 
@@ -96,7 +98,7 @@ class FuzzerUtils {
     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 (!equalOrNull(a.getMessage(), b.getMessage())) return false; // Different messages. Null is allowed as wildcard
+        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
diff --git a/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java b/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
index 2ef0a3fd..3731b40c 100644
--- a/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
+++ b/src/test/java/com/seaofnodes/simple/fuzzer/Reducer.java
@@ -1,7 +1,10 @@
 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;
 
 /**
@@ -13,35 +16,45 @@ import java.util.regex.Pattern;
  */
 public class Reducer {
 
+    private interface Replacer extends BiConsumer<StringBuilder, Matcher> {}
+
     /**
      * Holder for the rewrite rules
      */
-    private record Replace(Pattern p, String r) {}
+    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("\\b\\+-"), "-"),
-            new Replace(Pattern.compile("\\bfalse\\b"), "0"),
-            new Replace(Pattern.compile("\\btrue\\b"), "1"),
             new Replace(Pattern.compile("-"), ""),
+            new Replace(Pattern.compile("\\b\\+-"), "-"),
             new Replace(Pattern.compile("(?<![+\\-*/<>=])(?:-|\\*|/|>=|<=|>|<|!=|==)(?![+\\-*/<>=])"), "+"),
-            new Replace(Pattern.compile("\\{(?:[^{}]|\\{})+}"), "{}"),
-            new Replace(Pattern.compile("\\{((?:[^{}]|\\{})+)}"), "$1"),
-            new Replace(Pattern.compile("\\(([^()]+)\\)"), "$1"),
-            new Replace(Pattern.compile("\\b\\w+\\b"), "0"),
-            new Replace(Pattern.compile("\\b(?:[^\\W0]|\\w\\w+)\\b"), "1"),
+            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|$)"), "\n"),
-            new Replace(Pattern.compile("\\n+"), "\n"),
+            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+ \\{[^{}]*}"), "")
     };
 
     /**
@@ -60,24 +73,31 @@ public class Reducer {
     /**
      * Rewrites the script with one rewrite rule.
      */
-    private String doReplacement(String script, Pattern pattern, String with) {
+    private String doReplacement(String script, Pattern pattern, Replacer[] replacements) {
         var matcher = pattern.matcher(script);
         var sb = new StringBuilder();
-        int last = 0;
-        while (matcher.find()) {
+        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();
-            matcher.appendReplacement(sb, with);
-            var tail = sb.length();
-            matcher.appendTail(sb);
-            if (tester.test(sb.toString())) {
-                sb.setLength(tail);
-            } else {
+            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);
-                sb.append(script, last, matcher.end());
             }
-            last = matcher.end();
+            last = matcher.start();
+            skip = 1;
         }
-        matcher.appendTail(sb);
+        sb.append(script, last, script.length());
         return sb.toString();
     }
 
@@ -85,13 +105,21 @@ public class Reducer {
      * Clean up variable names from the random ones generated by the fuzzer.
      */
     private String cleanVariables(String script) {
-        var matcher = Pattern.compile("\\bint ([0-9a-zA-Z_]+)").matcher(script);
-        int num = 0;
+        var matcher = Pattern.compile("\\b([0-9a-zA-Z_]+) ([0-9a-zA-Z_]+)").matcher(script);
+        int[] num = {0, 0};
         while (matcher.find()) {
-            var var = matcher.group(1);
-            if (var.matches("v\\d+")) continue;
-            while (script.contains("v"+num)) num++;
-            var n = script.replaceAll("\\b"+var+"\\b", "v" + num);
+            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;
             }
@@ -104,7 +132,11 @@ public class Reducer {
      */
     private String doAllReplacements(String script) {
         for (var replace: REPLACEMENTS) {
-            script = doReplacement(script, replace.p, replace.r);
+            String old;
+            do {
+                old = script;
+                script = doReplacement(script, replace.pattern, replace.replacements);
+            } while (replace.iterate && !old.equals(script));
         }
         return script;
     }
diff --git a/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java b/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
index ad98f7e2..155063ab 100644
--- a/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
+++ b/src/test/java/com/seaofnodes/simple/fuzzer/ScriptGenerator.java
@@ -6,6 +6,7 @@ import com.seaofnodes.simple.node.ScopeNode;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Random;
+import java.util.function.Predicate;
 
 /**
  * Generate a pseudo random script.
@@ -15,6 +16,13 @@ import java.util.Random;
  */
 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;
+
     /**
      * Number of spaces per indentation
      */
@@ -53,6 +61,51 @@ public class ScriptGenerator {
      */
     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) {}
+        final Field[] fields;
+        final TypeNullable nullable = new TypeNullable(this);
+        TypeStruct(String name, Field[] fields) {
+            super(name);
+            this.fields = fields;
+        }
+        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_INT = new Type("int");
+
+
+    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.
@@ -77,24 +130,33 @@ public class ScriptGenerator {
     /**
      * The depth of blocks allowed.
      */
-    private int depth = 20;
+    private int depth = MAX_BLOCK_DEPTH;
     /**
      * The depth of expressions allowed.
      */
-    private int exprDepth = 30;
+    private int exprDepth = MAX_EXPRESSION_DEPTH;
     /**
      * Current variables in scope.
      */
-    private final ArrayList<String> variables = new ArrayList<>();
+    private final ArrayList<Variable> variables = new ArrayList<>();
+    /**
+     * All defined structs.
+     */
+    private final ArrayList<TypeStruct> structs = 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 final boolean generateValid;
+    private boolean generateValid;
     /**
      * If this script might be invalid.
      */
     private boolean maybeInvalid = false;
 
+
     /**
      *
      * @param random the random number generator.
@@ -135,7 +197,7 @@ public class ScriptGenerator {
      * @return The random name generated
      */
     private StringBuilder getRandomName() {
-        int len = random.nextInt(30) + 1;
+        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++)
@@ -144,6 +206,90 @@ public class ScriptGenerator {
     }
 
     /**
+     * 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;
+        }
+        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.
@@ -152,35 +298,67 @@ public class ScriptGenerator {
         if (currScopeStart > 0 && random.nextInt(10) > 7) {
             // Use a variable outside the current scope.
             var v = variables.get(random.nextInt(currScopeStart));
-            if (variables.lastIndexOf(v) < currScopeStart) return v;
+            if (lookup(v.name) < currScopeStart) return v.name;
             if (!generateValid) {
                 maybeInvalid = true;
-                return v;
+                return v.name;
             }
         }
         // Generate a new random variable name
         StringBuilder sb = getRandomName();
         var v = sb.toString();
-        if (!generateValid && (KEYWORDS.contains(v) || variables.lastIndexOf(v) >= currScopeStart)) {
+        if (!generateValid && (KEYWORDS.contains(v) || lookup(v) >= currScopeStart)) {
             maybeInvalid = true;
             return v;
         }
-        while (KEYWORDS.contains(v) || variables.lastIndexOf(v) >= currScopeStart) {
+        while (KEYWORDS.contains(v) || lookup(v) >= currScopeStart) {
             sb.append(VAR_CHARS.charAt(random.nextInt(VAR_CHARS.length())));
             v = sb.toString();
         }
         return v;
     }
 
+    /**
+     * Get a random structure name
+     * @return A random structure name
+     */
+    private String getStructName() {
+        if (!structs.isEmpty() && generateInvalid()) return structs.get(random.nextInt(structs.size())).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;
+    }
 
+    /**
+     * Get a random type
+     * @return A random type
+     */
+    private Type getType() {
+        if (structs.isEmpty() || random.nextBoolean()) return TYPE_INT;
+        var idx = random.nextInt(structs.size());
+        TypeStruct struct = structs.get(idx);
+        if (random.nextBoolean()) return struct.nullable;
+        return struct;
+    }
 
     /**
      * 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;
-        variables.add(ScopeNode.ARG0);
+        addVariable(ScopeNode.ARG0, TYPE_INT);
         currScopeStart = variables.size();
         if ((genStatements() & FLAG_STOP) == 0) {
             if (generateValid || random.nextInt(10)<7) {
@@ -189,6 +367,7 @@ public class ScriptGenerator {
                 this.maybeInvalid = true;
             }
         }
+        generateValid = oldGenerateValid;
         return !this.maybeInvalid;
     }
 
@@ -197,7 +376,7 @@ public class ScriptGenerator {
      * @return flags FLAG_STOP and FLAG_IF_WITHOUT_ELSE for the last statement generated
      */
     public int genStatements() {
-        var num = random.nextInt(10); // (30);
+        var num = random.nextInt(MAX_STATEMENTS_PER_BLOCK * (depth+1));
         for (int i=0; i<num; i++) {
             printIndentation();
             var stop = genStatement();
@@ -212,29 +391,55 @@ public class ScriptGenerator {
      * @return flags FLAG_STOP and FLAG_IF_WITHOUT_ELSE for the generated statement
      */
     public int genStatement() {
-        return switch (random.nextInt(10)) {
+        return switch (random.nextInt(12)) {
+            case 0 -> allowStructs || generateInvalid() ? genStruct() : genAssignment();
             case 1 -> genBlock();
             case 2 -> genIf();
-            case 3 -> genWhile();
-            case 4, 5 -> genDecl();
-            case 6, 7, 8 -> genAssignment();
+            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() {
+        var name = getStructName();
+        var fields = new TypeStruct.Field[generateInvalid() ? 0 : random.nextInt(10)];
+        sb.append("struct ").append(name).append(" {\n");
+        indentation += INDENTATION;
+        for (int i=0; i<fields.length; i++) {
+            var fieldName = getRandomName();
+            var type = generateInvalid() ? getType() : TYPE_INT;
+            printIndentation().append(type.name).append(" ").append(fieldName).append(";\n");
+            fields[i] = new TypeStruct.Field(fieldName.toString(), type);
+        }
+        indentation -= INDENTATION;
+        printIndentation().append("}");
+        structs.add(new TypeStruct(name, fields));
+        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(10)) {
+            res = switch (random.nextInt(12)) {
                 case 1, 2, 3, 4, 5 -> {
                     depth++;
                     indentation -= INDENTATION;
@@ -244,13 +449,16 @@ public class ScriptGenerator {
                     yield ret;
                 }
                 case 6 -> genIf();
-                case 7 -> genWhile();
-                case 8 -> genAssignment();
+                case 7 -> genCountedLoop();
+                case 8 -> genWhile();
+                case 9 -> genAssignment();
+                case 10 -> genNullCheck();
                 default -> genExit();
             };
             depth++;
         }
         indentation -= INDENTATION;
+        allowStructs = oldAllowStructs;
         return res;
     }
 
@@ -284,18 +492,20 @@ public class ScriptGenerator {
             sb.append("{}");
             return 0;
         }
-        depth--;
-        int oldCSS = currScopeStart;
+        var oldAllowStructs = allowStructs;
+        var oldCSS = currScopeStart;
+        allowStructs = false;
         currScopeStart = variables.size();
+        depth--;
         sb.append("{\n");
         indentation += INDENTATION;
         var stop = genStatements();
         indentation -= INDENTATION;
         printIndentation().append("}");
-        while (variables.size() > currScopeStart)
-            variables.removeLast();
-        currScopeStart = oldCSS;
+        popVariables(currScopeStart);
         depth++;
+        currScopeStart = oldCSS;
+        allowStructs = oldAllowStructs;
         return stop & ~FLAG_IF_WITHOUT_ELSE;
     }
 
@@ -305,7 +515,7 @@ public class ScriptGenerator {
      */
     public int genIf() {
         sb.append("if(");
-        genExpression();
+        genExpression(TYPE_INT);
         sb.append(") ");
         var stop = genStatementBlock();
         if ((stop & FLAG_IF_WITHOUT_ELSE) == 0 && random.nextInt(10) > 3) {
@@ -319,12 +529,39 @@ public class ScriptGenerator {
     }
 
     /**
+     * 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();
+        genExpression(TYPE_INT);
         sb.append(") ");
         loopDepth++;
         genStatementBlock();
@@ -333,15 +570,61 @@ public class ScriptGenerator {
     }
 
     /**
+     * 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);
+        sb.append(";\n");
+        addVariable(name, TYPE_INT);
+        printIndentation().append("while(").append(name).append("<");
+        genExpression(TYPE_INT);
+        sb.append(") {\n");
+        indentation += INDENTATION;
+        depth--;
+        loopDepth++;
+        printIndentation().append(name).append("=").append(name).append("+");
+        genExpression(TYPE_INT);
+        sb.append(";\n");
+        genStatements();
+        loopDepth--;
+        depth++;
+        indentation -= INDENTATION;
+        printIndentation().append("}\n");
+        indentation -= INDENTATION;
+        printIndentation().append("}");
+        popVariables(currScopeStart);
+        currScopeStart = oldCSS;
+        return 0;
+    }
+
+    /**
      * Generate a declaration statement.
      * @return 0
      */
     public int genDecl() {
-        String name = getVarName();
-        sb.append("int ").append(name).append("=");
-        genExpression();
+        var type = getType();
+        var name = getVarName();
+        sb.append(generateInvalid() ? getRandomName() : type.name).append(" ").append(name);
+        if (!(type instanceof TypeNullable) || random.nextBoolean()) {
+            sb.append("=");
+            genExpression(type);
+        }
         sb.append(";");
-        variables.add(name);
+        addVariable(name, type);
         return 0;
     }
 
@@ -350,10 +633,30 @@ public class ScriptGenerator {
      * @return 0
      */
     public int genAssignment() {
-        if (variables.isEmpty()) return genDecl();
-        genVariable();
+        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();
+        genExpression(declared);
         sb.append(";");
         return 0;
     }
@@ -363,94 +666,127 @@ public class ScriptGenerator {
      * @return FLAG_STOP
      */
     public int genReturn() {
+        var type = getType();
         sb.append("return ");
-        genExpression();
+        genExpression(type);
         sb.append(";");
         return FLAG_STOP;
     }
 
-
     /**
      * Generate a binary expression.
      * This method does not care about operator precedence.
      */
-    public void genExpression() {
-        var num = randLog(10);
+    public void genExpression(Type type) {
+        if (generateInvalid()) type = getType();
+        if (type != TYPE_INT) {
+            genUnary(type);
+            return;
+        }
+        var num = randLog(MAX_BINARY_EXPRESSIONS_PER_EXPRESSION);
         while(num-->0) {
-            genUnary();
+            genUnary(TYPE_INT);
             sb.append(BINARY_OP[random.nextInt(BINARY_OP.length)]);
         }
-        genUnary();
+        genUnary(TYPE_INT);
     }
 
     /**
      * Generate a unary expression.
      */
-    public void genUnary() {
-        var num = randLog(6);
+    public void genUnary(Type type) {
+        if (generateInvalid()) type = getType();
+        if (type != TYPE_INT) {
+            genSuffix(type);
+            return;
+        }
+        var num = randLog(MAX_UNARY_EXPRESSIONS_PER_EXPRESSION);
         while(num-->0) {
             sb.append(UNARY_OP[random.nextInt(UNARY_OP.length)]);
         }
-        genPrimary();
+        genSuffix(TYPE_INT);
+    }
+
+    /**
+     * Generate
+     */
+    public void genSuffix(Type type) {
+        if (generateInvalid()) type = getType();
+        if (type == TYPE_INT && random.nextBoolean()) {
+            var t = getType();
+            if (generateInvalid()) {
+                var field = getRandomName();
+                genPrimary(t);
+                sb.append(".").append(field);
+                return;
+            } else if (t instanceof TypeStruct s && s.fields.length > 0) {
+                var field = s.fields[random.nextInt(s.fields.length)];
+                if (field.type == TYPE_INT) {
+                    genPrimary(t);
+                    sb.append(".").append(field.name);
+                    return;
+                }
+            }
+        }
+        genPrimary(type);
     }
 
     /**
      * Generate a primary expression.
      */
-    public void genPrimary() {
-        switch (random.nextInt(10)) {
-            case 0:
-                sb.append("true");
-                break;
-            case 1:
-                sb.append("false");
-                break;
-            case 2:
-                if (exprDepth == 0) {
-                    // Ensure termination of the generator.
-                    if (random.nextBoolean()) {
-                        genNumber();
-                    } else {
-                        genVariable();
-                    }
-                } else {
-                    sb.append("(");
-                    exprDepth--;
-                    genExpression();
-                    exprDepth++;
-                    sb.append(")");
-                }
-                break;
-            case 3, 4, 5, 6:
-                genNumber();
-                break;
-            default:
-                genVariable();
+    public void genPrimary(Type type) {
+        if (generateInvalid()) type = getType();
+        var rand = random.nextInt(10);
+        if (rand == 0 && exprDepth != 0) {
+            sb.append("(");
+            exprDepth--;
+            genExpression(type);
+            exprDepth++;
+            sb.append(")");
+        } else if (rand < 6) {
+            genVariable(type);
+        } else {
+            genConst(type);
         }
     }
 
     /**
-     * Generate a number.
+     * Generate a constant.
      */
-    public void genNumber() {
-        sb.append(random.nextInt(100));
+    public void genConst(Type type) {
+        if (generateInvalid()) type = getType();
+        if (type == TYPE_INT) {
+            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 instanceof TypeNullable n) {
+            if (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() {
-        if (!generateValid && random.nextInt(100)>97) {
+    public void genVariable(Type type) {
+        if (generateInvalid()) {
             sb.append(getRandomName());
-            maybeInvalid = true;
             return;
         }
-        if (variables.isEmpty()) {
-            genNumber();
-        } else {
-            sb.append(variables.get(random.nextInt(variables.size())));
-        }
+        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);
     }
 
 }