ART: Change indentation to 4 spaces in run-test shards 15-19.

Created with
    for testName in \
        `git grep -E '^  public static void main\(String\[\]' \
            -- test/*<i>-*/src/Main.java | \
        sed '-es/\/src\/Main.java:.*//'`; \
    do \
        find $testName/ -type f -name *.java | \
        xargs sed -E '-es/^((  )+)/\1\1/' --in-place ; \
    done
with <i> manually set to 15 to 19.

Manually address many long lines and fix other style issues.

Test: testrunner.py --host --optimizing
Change-Id: I20e443155e4a2c91a6c484f24783c0d4b87ca928

27 files changed, 2070 insertions, 2068 deletions

diff --git a/test/118-noimage-dex2oat/src/Main.java b/test/118-noimage-dex2oat/src/Main.java
index cc19107590..f83cadc6f5 100644
--- a/test/118-noimage-dex2oat/src/Main.java
+++ b/test/118-noimage-dex2oat/src/Main.java
@@ -18,68 +18,68 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    System.loadLibrary(args[0]);
-    boolean hasImage = hasImage();
-    String instructionSet = VMRuntime.getCurrentInstructionSet();
-    boolean isBootClassPathOnDisk = VMRuntime.isBootClassPathOnDisk(instructionSet);
-    System.out.println(
-        "Has image is " + hasImage + ", is image dex2oat enabled is "
-        + isImageDex2OatEnabled() + ", is BOOTCLASSPATH on disk is "
-        + isBootClassPathOnDisk + ".");
+    public static void main(String[] args) throws Exception {
+        System.loadLibrary(args[0]);
+        boolean hasImage = hasImage();
+        String instructionSet = VMRuntime.getCurrentInstructionSet();
+        boolean isBootClassPathOnDisk = VMRuntime.isBootClassPathOnDisk(instructionSet);
+        System.out.println(
+                "Has image is " + hasImage + ", is image dex2oat enabled is "
+                + isImageDex2OatEnabled() + ", is BOOTCLASSPATH on disk is "
+                + isBootClassPathOnDisk + ".");
 
-    if (hasImage && !isImageDex2OatEnabled()) {
-      throw new Error("Image with dex2oat disabled runs with an oat file");
-    } else if (!hasImage && isImageDex2OatEnabled()) {
-      throw new Error("Image with dex2oat enabled runs without an oat file");
-    }
-    if (hasImage && !isBootClassPathOnDisk) {
-      throw new Error("Image with dex2oat disabled runs with an image file");
-    } else if (!hasImage && isBootClassPathOnDisk) {
-      throw new Error("Image with dex2oat enabled runs without an image file");
-    }
+        if (hasImage && !isImageDex2OatEnabled()) {
+            throw new Error("Image with dex2oat disabled runs with an oat file");
+        } else if (!hasImage && isImageDex2OatEnabled()) {
+            throw new Error("Image with dex2oat enabled runs without an oat file");
+        }
+        if (hasImage && !isBootClassPathOnDisk) {
+            throw new Error("Image with dex2oat disabled runs with an image file");
+        } else if (!hasImage && isBootClassPathOnDisk) {
+            throw new Error("Image with dex2oat enabled runs without an image file");
+        }
 
-    testB18485243();
-  }
+        testB18485243();
+    }
 
-  private native static boolean hasImage();
+    private native static boolean hasImage();
 
-  private native static boolean isImageDex2OatEnabled();
+    private native static boolean isImageDex2OatEnabled();
 
-  private static class VMRuntime {
-    private static final Method getCurrentInstructionSetMethod;
-    private static final Method isBootClassPathOnDiskMethod;
-    static {
-        try {
-            Class<?> c = Class.forName("dalvik.system.VMRuntime");
-            getCurrentInstructionSetMethod = c.getDeclaredMethod("getCurrentInstructionSet");
-            isBootClassPathOnDiskMethod = c.getDeclaredMethod("isBootClassPathOnDisk",
-                                                              String.class);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
+    private static class VMRuntime {
+        private static final Method getCurrentInstructionSetMethod;
+        private static final Method isBootClassPathOnDiskMethod;
+        static {
+            try {
+                Class<?> c = Class.forName("dalvik.system.VMRuntime");
+                getCurrentInstructionSetMethod = c.getDeclaredMethod("getCurrentInstructionSet");
+                isBootClassPathOnDiskMethod =
+                        c.getDeclaredMethod("isBootClassPathOnDisk", String.class);
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
         }
-    }
 
-    public static String getCurrentInstructionSet() throws Exception {
-      return (String) getCurrentInstructionSetMethod.invoke(null);
-    }
-    public static boolean isBootClassPathOnDisk(String instructionSet) throws Exception {
-      return (boolean) isBootClassPathOnDiskMethod.invoke(null, instructionSet);
+        public static String getCurrentInstructionSet() throws Exception {
+            return (String) getCurrentInstructionSetMethod.invoke(null);
+        }
+        public static boolean isBootClassPathOnDisk(String instructionSet) throws Exception {
+            return (boolean) isBootClassPathOnDiskMethod.invoke(null, instructionSet);
+        }
     }
-  }
 
-  private static void testB18485243() throws Exception {
-    Class<?> k = Class.forName("B18485243");
-    Object o = k.newInstance();
-    Method m = k.getDeclaredMethod("run");
-    try {
-      m.invoke(o);
-    } catch (InvocationTargetException e) {
-      Throwable actual = e.getTargetException();
-      if (!(actual instanceof IncompatibleClassChangeError)) {
-        throw new AssertionError("Expected IncompatibleClassChangeError", actual);
-      }
+    private static void testB18485243() throws Exception {
+        Class<?> k = Class.forName("B18485243");
+        Object o = k.newInstance();
+        Method m = k.getDeclaredMethod("run");
+        try {
+            m.invoke(o);
+        } catch (InvocationTargetException e) {
+            Throwable actual = e.getTargetException();
+            if (!(actual instanceof IncompatibleClassChangeError)) {
+                throw new AssertionError("Expected IncompatibleClassChangeError", actual);
+            }
+        }
+        System.out.println("testB18485243 PASS");
     }
-    System.out.println("testB18485243 PASS");
-  }
 }
diff --git a/test/1915-get-set-local-current-thread/src/Main.java b/test/1915-get-set-local-current-thread/src/Main.java
index 47e676704f..5ca6f0964e 100644
--- a/test/1915-get-set-local-current-thread/src/Main.java
+++ b/test/1915-get-set-local-current-thread/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test1915.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test1915.run();
+    }
 }
diff --git a/test/1915-get-set-local-current-thread/src/art/Test1915.java b/test/1915-get-set-local-current-thread/src/art/Test1915.java
index a99a487ea6..8398afa254 100644
--- a/test/1915-get-set-local-current-thread/src/art/Test1915.java
+++ b/test/1915-get-set-local-current-thread/src/art/Test1915.java
@@ -31,75 +31,75 @@ import java.util.function.Supplier;
 import java.util.function.Consumer;
 
 public class Test1915 {
-  public static final int SET_VALUE = 1337;
-  public static final String TARGET_VAR = "TARGET";
+    public static final int SET_VALUE = 1337;
+    public static final String TARGET_VAR = "TARGET";
 
-  public static void reportValue(Object val) {
-    System.out.println("\tValue is '" + val + "'");
-  }
-  public static interface ThrowRunnable {
-    public void run() throws Exception;
-  }
+    public static void reportValue(Object val) {
+        System.out.println("\tValue is '" + val + "'");
+    }
+    public static interface ThrowRunnable {
+        public void run() throws Exception;
+    }
 
-  public static void IntMethod(ThrowRunnable safepoint) throws Exception {
-    int TARGET = 42;
-    safepoint.run();
-    reportValue(TARGET);
-  }
+    public static void IntMethod(ThrowRunnable safepoint) throws Exception {
+        int TARGET = 42;
+        safepoint.run();
+        reportValue(TARGET);
+    }
 
-  public static void run() throws Exception {
-    Locals.EnableLocalVariableAccess();
-    final Method target = Test1915.class.getDeclaredMethod("IntMethod", ThrowRunnable.class);
-    // Get Variable.
-    System.out.println("GetLocalInt on current thread!");
-    IntMethod(() -> {
-      StackTrace.StackFrameData frame = FindStackFrame(target);
-      int depth = FindExpectedFrameDepth(frame);
-      int slot = FindSlot(frame);
-      int value = Locals.GetLocalVariableInt(Thread.currentThread(), depth, slot);
-      System.out.println("From GetLocalInt(), value is " + value);
-    });
-    // Set Variable.
-    System.out.println("SetLocalInt on current thread!");
-    IntMethod(() -> {
-      StackTrace.StackFrameData frame = FindStackFrame(target);
-      int depth = FindExpectedFrameDepth(frame);
-      int slot = FindSlot(frame);
-      Locals.SetLocalVariableInt(Thread.currentThread(), depth, slot, SET_VALUE);
-    });
-  }
+    public static void run() throws Exception {
+        Locals.EnableLocalVariableAccess();
+        final Method target = Test1915.class.getDeclaredMethod("IntMethod", ThrowRunnable.class);
+        // Get Variable.
+        System.out.println("GetLocalInt on current thread!");
+        IntMethod(() -> {
+            StackTrace.StackFrameData frame = FindStackFrame(target);
+            int depth = FindExpectedFrameDepth(frame);
+            int slot = FindSlot(frame);
+            int value = Locals.GetLocalVariableInt(Thread.currentThread(), depth, slot);
+            System.out.println("From GetLocalInt(), value is " + value);
+        });
+        // Set Variable.
+        System.out.println("SetLocalInt on current thread!");
+        IntMethod(() -> {
+            StackTrace.StackFrameData frame = FindStackFrame(target);
+            int depth = FindExpectedFrameDepth(frame);
+            int slot = FindSlot(frame);
+            Locals.SetLocalVariableInt(Thread.currentThread(), depth, slot, SET_VALUE);
+        });
+    }
 
-  public static int FindSlot(StackTrace.StackFrameData frame) throws Exception {
-    long loc = frame.current_location;
-    for (Locals.VariableDescription var : Locals.GetLocalVariableTable(frame.method)) {
-      if (var.start_location <= loc &&
-          var.length + var.start_location > loc &&
-          var.name.equals(TARGET_VAR)) {
-        return var.slot;
-      }
+    public static int FindSlot(StackTrace.StackFrameData frame) throws Exception {
+        long loc = frame.current_location;
+        for (Locals.VariableDescription var : Locals.GetLocalVariableTable(frame.method)) {
+            if (var.start_location <= loc &&
+                    var.length + var.start_location > loc &&
+                    var.name.equals(TARGET_VAR)) {
+                return var.slot;
+            }
+        }
+        throw new Error(
+                "Unable to find variable " + TARGET_VAR + " in " + frame.method + " at loc " + loc);
     }
-    throw new Error(
-        "Unable to find variable " + TARGET_VAR + " in " + frame.method + " at loc " + loc);
-  }
 
-  public static int FindExpectedFrameDepth(StackTrace.StackFrameData frame) throws Exception {
-    // Adjust the 'frame' depth since it is modified by:
-    // +1 for Get/SetLocalVariableInt in future.
-    // -1 for FindStackFrame
-    // -1 for GetStackTrace
-    // -1 for GetStackTraceNative
-    // ------------------------------
-    // -2
-    return frame.depth - 2;
-  }
+    public static int FindExpectedFrameDepth(StackTrace.StackFrameData frame) throws Exception {
+        // Adjust the 'frame' depth since it is modified by:
+        // +1 for Get/SetLocalVariableInt in future.
+        // -1 for FindStackFrame
+        // -1 for GetStackTrace
+        // -1 for GetStackTraceNative
+        // ------------------------------
+        // -2
+        return frame.depth - 2;
+    }
 
-  private static StackTrace.StackFrameData FindStackFrame(Method target) {
-    for (StackTrace.StackFrameData frame : StackTrace.GetStackTrace(Thread.currentThread())) {
-      if (frame.method.equals(target)) {
-        return frame;
-      }
+    private static StackTrace.StackFrameData FindStackFrame(Method target) {
+        for (StackTrace.StackFrameData frame : StackTrace.GetStackTrace(Thread.currentThread())) {
+            if (frame.method.equals(target)) {
+                return frame;
+            }
+        }
+        throw new Error("Unable to find stack frame in method " + target);
     }
-    throw new Error("Unable to find stack frame in method " + target);
-  }
 }
 
diff --git a/test/1917-get-stack-frame/src/Main.java b/test/1917-get-stack-frame/src/Main.java
index c055a5c540..c6f0853d44 100644
--- a/test/1917-get-stack-frame/src/Main.java
+++ b/test/1917-get-stack-frame/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test1917.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test1917.run();
+    }
 }
diff --git a/test/1917-get-stack-frame/src/art/Test1917.java b/test/1917-get-stack-frame/src/art/Test1917.java
index 75af43bea3..47b06cfa21 100644
--- a/test/1917-get-stack-frame/src/art/Test1917.java
+++ b/test/1917-get-stack-frame/src/art/Test1917.java
@@ -34,124 +34,124 @@ import java.util.function.Supplier;
 import java.util.function.Consumer;
 
 public class Test1917 {
-  public final static boolean TEST_PRINT_ALL = false;
-
-  public static class ThreadPauser implements Runnable {
-    public Semaphore sem_wakeup_main = new Semaphore(0);
-    public Semaphore sem_wait = new Semaphore(0);
-
-    public void run() {
-      try {
-        sem_wakeup_main.release();
-        sem_wait.acquire();
-      } catch (Exception e) {
-        throw new Error("Error with semaphores!", e);
-      }
-    }
+    public final static boolean TEST_PRINT_ALL = false;
+
+    public static class ThreadPauser implements Runnable {
+        public Semaphore sem_wakeup_main = new Semaphore(0);
+        public Semaphore sem_wait = new Semaphore(0);
+
+        public void run() {
+            try {
+                sem_wakeup_main.release();
+                sem_wait.acquire();
+            } catch (Exception e) {
+                throw new Error("Error with semaphores!", e);
+            }
+        }
 
-    public void waitForOtherThreadToPause() throws Exception {
-      sem_wakeup_main.acquire();
-      while (!sem_wait.hasQueuedThreads()) {}
-    }
+        public void waitForOtherThreadToPause() throws Exception {
+            sem_wakeup_main.acquire();
+            while (!sem_wait.hasQueuedThreads()) {}
+        }
 
-    public void wakeupOtherThread() throws Exception {
-      sem_wait.release();
-    }
-  }
-
-  public static class StackTraceGenerator implements Runnable {
-    private final Thread thr;
-    private final Consumer<StackTrace.StackFrameData> con;
-    public StackTraceGenerator(Thread thr, Consumer<StackTrace.StackFrameData> con) {
-      this.thr = thr;
-      this.con = con;
+        public void wakeupOtherThread() throws Exception {
+            sem_wait.release();
+        }
     }
 
-    public StackTraceGenerator(Consumer<StackTrace.StackFrameData> con) {
-      this(null, con);
-    }
+    public static class StackTraceGenerator implements Runnable {
+        private final Thread thr;
+        private final Consumer<StackTrace.StackFrameData> con;
+        public StackTraceGenerator(Thread thr, Consumer<StackTrace.StackFrameData> con) {
+            this.thr = thr;
+            this.con = con;
+        }
 
-    public Thread getThread() {
-      if (thr == null) {
-        return Thread.currentThread();
-      } else {
-        return thr;
-      }
-    }
-    public void run() {
-      for (StackTrace.StackFrameData s : StackTrace.GetStackTrace(getThread())) {
-        con.accept(s);
-      }
+        public StackTraceGenerator(Consumer<StackTrace.StackFrameData> con) {
+            this(null, con);
+        }
+
+        public Thread getThread() {
+            if (thr == null) {
+                return Thread.currentThread();
+            } else {
+                return thr;
+            }
+        }
+        public void run() {
+            for (StackTrace.StackFrameData s : StackTrace.GetStackTrace(getThread())) {
+                con.accept(s);
+            }
+        }
     }
-  }
-
-  public static class RecurCount implements Runnable {
-    private final int cnt;
-    private final Runnable then;
-    public RecurCount(int cnt, Runnable then) {
-      this.cnt = cnt;
-      this.then = then;
+
+    public static class RecurCount implements Runnable {
+        private final int cnt;
+        private final Runnable then;
+        public RecurCount(int cnt, Runnable then) {
+            this.cnt = cnt;
+            this.then = then;
+        }
+
+        public void run() {
+            doRecur(0);
+        }
+
+        public void doRecur(int n) {
+            if (n < cnt) {
+                doRecur(n + 1);
+            } else {
+                then.run();
+            }
+        }
     }
 
-    public void run() {
-      doRecur(0);
+    public static Consumer<StackTrace.StackFrameData> makePrintStackFramesConsumer()
+            throws Exception {
+        final Method end_method = Test1917.class.getDeclaredMethod("run");
+        return new Consumer<StackTrace.StackFrameData>() {
+            public void accept(StackTrace.StackFrameData data) {
+                if (TEST_PRINT_ALL) {
+                    System.out.println(data);
+                } else {
+                    Package p = data.method.getDeclaringClass().getPackage();
+                    // Filter out anything to do with the testing harness.
+                    if (p != null && p.equals(Test1917.class.getPackage())) {
+                        System.out.printf("'%s' line: %d\n",
+                                data.method,
+                                Breakpoint.locationToLine(data.method, data.current_location));
+                    } else if (data.method.getDeclaringClass().equals(Semaphore.class)) {
+                        System.out.printf("'%s' line: <NOT-DETERMINISTIC>\n", data.method);
+                    }
+                }
+            }
+        };
     }
 
-    public void doRecur(int n) {
-      if (n < cnt) {
-        doRecur(n + 1);
-      } else {
-        then.run();
-      }
+    public static void run() throws Exception {
+        System.out.println("Recurring 5 times");
+        new RecurCount(5, new StackTraceGenerator(makePrintStackFramesConsumer())).run();
+
+        System.out.println("Recurring 5 times on another thread");
+        Thread thr = new Thread(
+                Thread.currentThread().getThreadGroup(),
+                new RecurCount(5, new StackTraceGenerator(makePrintStackFramesConsumer())),
+                "Recurring Thread 1",
+                10*1000000 /* 10 mb*/);
+        thr.start();
+        thr.join();
+
+        System.out.println("Recurring 5 times on another thread. Stack trace from main thread!");
+        ThreadPauser pause = new ThreadPauser();
+        Thread thr2 = new Thread(
+                Thread.currentThread().getThreadGroup(),
+                new RecurCount(5, pause),
+                "Recurring Thread 2",
+                10*1000000 /* 10 mb*/);
+        thr2.start();
+        pause.waitForOtherThreadToPause();
+        new StackTraceGenerator(thr2, makePrintStackFramesConsumer()).run();
+        pause.wakeupOtherThread();
+        thr2.join();
     }
-  }
-
-  public static Consumer<StackTrace.StackFrameData> makePrintStackFramesConsumer()
-      throws Exception {
-    final Method end_method = Test1917.class.getDeclaredMethod("run");
-    return new Consumer<StackTrace.StackFrameData>() {
-      public void accept(StackTrace.StackFrameData data) {
-        if (TEST_PRINT_ALL) {
-          System.out.println(data);
-        } else {
-          Package p = data.method.getDeclaringClass().getPackage();
-          // Filter out anything to do with the testing harness.
-          if (p != null && p.equals(Test1917.class.getPackage())) {
-            System.out.printf("'%s' line: %d\n",
-                data.method,
-                Breakpoint.locationToLine(data.method, data.current_location));
-          } else if (data.method.getDeclaringClass().equals(Semaphore.class)) {
-            System.out.printf("'%s' line: <NOT-DETERMINISTIC>\n", data.method);
-          }
-        }
-      }
-    };
-  }
-
-  public static void run() throws Exception {
-    System.out.println("Recurring 5 times");
-    new RecurCount(5, new StackTraceGenerator(makePrintStackFramesConsumer())).run();
-
-    System.out.println("Recurring 5 times on another thread");
-    Thread thr = new Thread(
-        Thread.currentThread().getThreadGroup(),
-        new RecurCount(5, new StackTraceGenerator(makePrintStackFramesConsumer())),
-        "Recurring Thread 1",
-        10*1000000 /* 10 mb*/);
-    thr.start();
-    thr.join();
-
-    System.out.println("Recurring 5 times on another thread. Stack trace from main thread!");
-    ThreadPauser pause = new ThreadPauser();
-    Thread thr2 = new Thread(
-        Thread.currentThread().getThreadGroup(),
-        new RecurCount(5, pause),
-        "Recurring Thread 2",
-        10*1000000 /* 10 mb*/);
-    thr2.start();
-    pause.waitForOtherThreadToPause();
-    new StackTraceGenerator(thr2, makePrintStackFramesConsumer()).run();
-    pause.wakeupOtherThread();
-    thr2.join();
-  }
 }
diff --git a/test/1919-vminit-thread-start-timing/src/Main.java b/test/1919-vminit-thread-start-timing/src/Main.java
index 41baf241d8..32a45c59b6 100644
--- a/test/1919-vminit-thread-start-timing/src/Main.java
+++ b/test/1919-vminit-thread-start-timing/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test1919.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test1919.run();
+    }
 }
diff --git a/test/1919-vminit-thread-start-timing/src/art/Test1919.java b/test/1919-vminit-thread-start-timing/src/art/Test1919.java
index 26ff49fffc..f146ae683d 100644
--- a/test/1919-vminit-thread-start-timing/src/art/Test1919.java
+++ b/test/1919-vminit-thread-start-timing/src/art/Test1919.java
@@ -17,49 +17,49 @@
 package art;
 
 public class Test1919 {
-  public static final boolean PRINT_ALL_THREADS = false;
+    public static final boolean PRINT_ALL_THREADS = false;
 
-  public static void run() throws Exception {
-    Thread testing_thread = getTestingThread();
-    // TODO(b/124284724): For unknown reasons the testing thread will sometimes SEGV after the test
-    // has otherwise completed successfully. This has only been observed on the release version of
-    // art (libart.so) and I haven't had any luck reproing it. I assume it has something to do with
-    // racing between the DetachCurrentThread and shutdown but I'm not sure. Since the runtime
-    // normally never shuts down anyway for now I'll just ensure everything gets cleaned up early to
-    // prevent the problem from showing up.
-    testing_thread.join();
-    for (Event e : getEvents()) {
-      if (e.thr != null) {
-        if (PRINT_ALL_THREADS ||
-            e.thr.equals(Thread.currentThread()) ||
-            e.thr.equals(testing_thread)) {
-          System.out.println(e.name + ": " + e.thr.getName());
+    public static void run() throws Exception {
+        Thread testing_thread = getTestingThread();
+        // TODO(b/124284724): For unknown reasons the testing thread will sometimes SEGV after the
+        // test has otherwise completed successfully. This has only been observed on the release
+        // version of art (libart.so) and I haven't had any luck reproing it. I assume it has
+        // something to do with racing between the DetachCurrentThread and shutdown but I'm not
+        // sure. Since the runtime normally never shuts down anyway for now I'll just ensure
+        // everything gets cleaned up early to prevent the problem from showing up.
+        testing_thread.join();
+        for (Event e : getEvents()) {
+            if (e.thr != null) {
+                if (PRINT_ALL_THREADS ||
+                        e.thr.equals(Thread.currentThread()) ||
+                        e.thr.equals(testing_thread)) {
+                    System.out.println(e.name + ": " + e.thr.getName());
+                }
+            }
         }
-      }
     }
-  }
 
-  static class Event {
-    public final String name;
-    public final Thread thr;
-    public Event(String name, Thread thr) {
-      this.name = name;
-      this.thr = thr;
+    static class Event {
+        public final String name;
+        public final Thread thr;
+        public Event(String name, Thread thr) {
+            this.name = name;
+            this.thr = thr;
+        }
     }
-  }
 
-  public static Event[] getEvents() {
-    String[] ns = getEventNames();
-    Thread[] ts = getEventThreads();
-    Event[] es = new Event[Math.min(ns.length, ts.length)];
-    for (int i = 0; i < es.length; i++) {
-      es[i] = new Event(ns[i], ts[i]);
+    public static Event[] getEvents() {
+        String[] ns = getEventNames();
+        Thread[] ts = getEventThreads();
+        Event[] es = new Event[Math.min(ns.length, ts.length)];
+        for (int i = 0; i < es.length; i++) {
+            es[i] = new Event(ns[i], ts[i]);
+        }
+        return es;
     }
-    return es;
-  }
 
-  public static native String[] getEventNames();
-  public static native Thread[] getEventThreads();
+    public static native String[] getEventNames();
+    public static native Thread[] getEventThreads();
 
-  public static native Thread getTestingThread();
+    public static native Thread getTestingThread();
 }
diff --git a/test/418-const-string/src/Main.java b/test/418-const-string/src/Main.java
index 7c1ffec18c..3b7d8e2a33 100644
--- a/test/418-const-string/src/Main.java
+++ b/test/418-const-string/src/Main.java
@@ -15,14 +15,14 @@
  */
 
 public class Main {
-  public static void main(String[] args) {
-    // First call: may go in slow path.
-    System.out.println($opt$ReturnHelloWorld());
-    // Second call: no slow path.
-    System.out.println($opt$ReturnHelloWorld());
-  }
+    public static void main(String[] args) {
+        // First call: may go in slow path.
+        System.out.println($opt$ReturnHelloWorld());
+        // Second call: no slow path.
+        System.out.println($opt$ReturnHelloWorld());
+    }
 
-  public static String $opt$ReturnHelloWorld() {
-    return "Hello World";
-  }
+    public static String $opt$ReturnHelloWorld() {
+        return "Hello World";
+    }
 }
diff --git a/test/419-long-parameter/src/Main.java b/test/419-long-parameter/src/Main.java
index 808b7f616b..f83b3f7d63 100644
--- a/test/419-long-parameter/src/Main.java
+++ b/test/419-long-parameter/src/Main.java
@@ -15,20 +15,20 @@
  */
 
 public class Main {
-  public static void main(String[] args) {
-    if ($opt$TestCallee(1.0, 2.0, 1L, 2L) != 1L) {
-      throw new Error("Unexpected result");
+    public static void main(String[] args) {
+        if ($opt$TestCallee(1.0, 2.0, 1L, 2L) != 1L) {
+            throw new Error("Unexpected result");
+        }
+        if ($opt$TestCaller() != 1L) {
+            throw new Error("Unexpected result");
+        }
     }
-    if ($opt$TestCaller() != 1L) {
-      throw new Error("Unexpected result");
-    }
-  }
 
-  public static long $opt$TestCallee(double a, double b, long c, long d) {
-    return d - c;
-  }
+    public static long $opt$TestCallee(double a, double b, long c, long d) {
+        return d - c;
+    }
 
-  public static long $opt$TestCaller() {
-    return $opt$TestCallee(1.0, 2.0, 1L, 2L);
-  }
+    public static long $opt$TestCaller() {
+        return $opt$TestCallee(1.0, 2.0, 1L, 2L);
+    }
 }
diff --git a/test/515-dce-dominator/src/Main.java b/test/515-dce-dominator/src/Main.java
index 8c6ce753bf..f36b90c440 100644
--- a/test/515-dce-dominator/src/Main.java
+++ b/test/515-dce-dominator/src/Main.java
@@ -17,10 +17,10 @@
 import java.lang.reflect.Method;
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    Class<?> c = Class.forName("Dominator");
-    Method m = c.getMethod("method", int.class);
-    Object[] arguments = { 5 };
-    m.invoke(null, arguments);
-  }
+    public static void main(String[] args) throws Exception {
+        Class<?> c = Class.forName("Dominator");
+        Method m = c.getMethod("method", int.class);
+        Object[] arguments = { 5 };
+        m.invoke(null, arguments);
+    }
 }
diff --git a/test/517-checker-builder-fallthrough/src/Main.java b/test/517-checker-builder-fallthrough/src/Main.java
index 14170f5e86..5bec07336a 100644
--- a/test/517-checker-builder-fallthrough/src/Main.java
+++ b/test/517-checker-builder-fallthrough/src/Main.java
@@ -18,15 +18,15 @@ import java.lang.reflect.*;
 
 public class Main {
 
-  public static int runTest(int input) throws Exception {
-    Class<?> c = Class.forName("TestCase");
-    Method m = c.getMethod("testCase", int.class);
-    return (Integer) m.invoke(null, input);
-  }
+    public static int runTest(int input) throws Exception {
+        Class<?> c = Class.forName("TestCase");
+        Method m = c.getMethod("testCase", int.class);
+        return (Integer) m.invoke(null, input);
+    }
 
-  public static void main(String[] args) throws Exception {
-    if (runTest(42) != 42) {
-      throw new Error("Expected 42");
+    public static void main(String[] args) throws Exception {
+        if (runTest(42) != 42) {
+            throw new Error("Expected 42");
+        }
     }
-  }
 }
diff --git a/test/518-null-array-get/src/Main.java b/test/518-null-array-get/src/Main.java
index 7090194d32..12e2442a68 100644
--- a/test/518-null-array-get/src/Main.java
+++ b/test/518-null-array-get/src/Main.java
@@ -18,37 +18,37 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    checkLoad("NullArrayFailInt2Object", true);
-    checkLoad("NullArrayFailObject2Int", true);
-    checkLoad("NullArraySuccessInt", false);
-    checkLoad("NullArraySuccessInt2Float", false);
-    checkLoad("NullArraySuccessShort", false);
-    checkLoad("NullArraySuccessRef", false);
-  }
+    public static void main(String[] args) throws Exception {
+        checkLoad("NullArrayFailInt2Object", true);
+        checkLoad("NullArrayFailObject2Int", true);
+        checkLoad("NullArraySuccessInt", false);
+        checkLoad("NullArraySuccessInt2Float", false);
+        checkLoad("NullArraySuccessShort", false);
+        checkLoad("NullArraySuccessRef", false);
+    }
 
-  private static void checkLoad(String className, boolean expectError) throws Exception {
-    Class<?> c;
-    try {
-      c = Class.forName(className);
-      if (expectError) {
-        throw new RuntimeException("Expected error for " + className);
-      }
-      Method m = c.getMethod("method");
-      try {
-        m.invoke(null);
-        throw new RuntimeException("Expected an InvocationTargetException");
-      } catch (InvocationTargetException e) {
-        if (!(e.getCause() instanceof NullPointerException)) {
-          throw new RuntimeException("Expected a NullPointerException");
+    private static void checkLoad(String className, boolean expectError) throws Exception {
+        Class<?> c;
+        try {
+            c = Class.forName(className);
+            if (expectError) {
+                throw new RuntimeException("Expected error for " + className);
+            }
+            Method m = c.getMethod("method");
+            try {
+                m.invoke(null);
+                throw new RuntimeException("Expected an InvocationTargetException");
+            } catch (InvocationTargetException e) {
+                if (!(e.getCause() instanceof NullPointerException)) {
+                    throw new RuntimeException("Expected a NullPointerException");
+                }
+                System.out.println(className);
+            }
+        } catch (VerifyError e) {
+            if (!expectError) {
+                throw new RuntimeException(e);
+            }
+            System.out.println(className);
         }
-        System.out.println(className);
-      }
-    } catch (VerifyError e) {
-      if (!expectError) {
-        throw new RuntimeException(e);
-      }
-      System.out.println(className);
     }
-  }
 }
diff --git a/test/519-bound-load-class/src/Main.java b/test/519-bound-load-class/src/Main.java
index cddeb093f7..c507aecddd 100644
--- a/test/519-bound-load-class/src/Main.java
+++ b/test/519-bound-load-class/src/Main.java
@@ -15,25 +15,25 @@
  */
 
 public class Main {
-  public static void main(String[] args) {
-    testInstanceOf();
-    try {
-      testNull();
-      throw new Error("Expected ClassClastException");
-    } catch (ClassCastException e) { /* ignore */ }
-  }
+    public static void main(String[] args) {
+        testInstanceOf();
+        try {
+            testNull();
+            throw new Error("Expected ClassClastException");
+        } catch (ClassCastException e) { /* ignore */ }
+    }
 
-  public static void testInstanceOf() {
-    Object o = Main.class;
-    if (o instanceof Main) {
-      System.out.println((Main)o);
+    public static void testInstanceOf() {
+        Object o = Main.class;
+        if (o instanceof Main) {
+            System.out.println((Main) o);
+        }
     }
-  }
 
-  public static void testNull() {
-    Object o = Main.class;
-    if (o != null) {
-      System.out.println((Main)o);
+    public static void testNull() {
+        Object o = Main.class;
+        if (o != null) {
+            System.out.println((Main) o);
+        }
     }
-  }
 }
diff --git a/test/617-clinit-oome/src/Main.java b/test/617-clinit-oome/src/Main.java
index bab344f477..005f0df3d0 100644
--- a/test/617-clinit-oome/src/Main.java
+++ b/test/617-clinit-oome/src/Main.java
@@ -15,43 +15,43 @@
  */
 
 public class Main {
-  private static int exhaustJavaHeap(Object[] data, int index, int size) {
-    Runtime.getRuntime().gc();
-    while (size > 0) {
-        try {
-            data[index] = new byte[size];
-            index++;
-        } catch (OutOfMemoryError e) {
-            size /= 2;
+    private static int exhaustJavaHeap(Object[] data, int index, int size) {
+        Runtime.getRuntime().gc();
+        while (size > 0) {
+            try {
+                data[index] = new byte[size];
+                index++;
+            } catch (OutOfMemoryError e) {
+                size /= 2;
+            }
         }
+        return index;
     }
-    return index;
-  }
 
-  public static void main(String[] args) {
-    Class klass = Other.class;
-    Object[] data = new Object[100000];
-    try {
-        System.out.println("Filling heap");
+    public static void main(String[] args) {
+        Class klass = Other.class;
+        Object[] data = new Object[100000];
+        try {
+            System.out.println("Filling heap");
 
-        // Make sure that there is no reclaimable memory in the heap. Otherwise we may throw
-        // OOME to prevent GC thrashing, even if later allocations may succeed.
-        Runtime.getRuntime().gc();
-        System.runFinalization();
-        // NOTE: There is a GC invocation in the exhaustJavaHeap(). So we don't need one here.
+            // Make sure that there is no reclaimable memory in the heap. Otherwise we may throw
+            // OOME to prevent GC thrashing, even if later allocations may succeed.
+            Runtime.getRuntime().gc();
+            System.runFinalization();
+            // NOTE: There is a GC invocation in the exhaustJavaHeap(). So we don't need one here.
 
-        int index = 0;
-        int initial_size = 256 * 1024 * 1024;
-        // Repeat to ensure there is no space left on the heap.
-        index = exhaustJavaHeap(data, index, initial_size);
-        index = exhaustJavaHeap(data, index, /*size*/ 4);
-        index = exhaustJavaHeap(data, index, /*size*/ 4);
+            int index = 0;
+            int initial_size = 256 * 1024 * 1024;
+            // Repeat to ensure there is no space left on the heap.
+            index = exhaustJavaHeap(data, index, initial_size);
+            index = exhaustJavaHeap(data, index, /*size*/ 4);
+            index = exhaustJavaHeap(data, index, /*size*/ 4);
 
-        // Initialize now that the heap is full.
-        Other.print();
-    } catch (OutOfMemoryError e) {
-    } catch (Exception e) {
-        System.out.println(e);
+            // Initialize now that the heap is full.
+            Other.print();
+        } catch (OutOfMemoryError e) {
+        } catch (Exception e) {
+            System.out.println(e);
+        }
     }
-  }
 }
diff --git a/test/618-checker-induction/src/Main.java b/test/618-checker-induction/src/Main.java
index 824a8dbd17..d15de18637 100644
--- a/test/618-checker-induction/src/Main.java
+++ b/test/618-checker-induction/src/Main.java
@@ -19,1017 +19,1027 @@
  */
 public class Main {
 
-  static int[] a = new int[10];
+    static int[] a = new int[10];
 
-  static int[] novec = new int[20];  // to prevent vectorization
+    static int[] novec = new int[20];  // to prevent vectorization
 
-  /// CHECK-START: void Main.deadSingleLoop() loop_optimization (before)
-  /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
-  //
-  /// CHECK-START: void Main.deadSingleLoop() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  static void deadSingleLoop() {
-    for (int i = 0; i < 4; i++) {
-    }
-  }
-
-  /// CHECK-START: void Main.deadSingleLoop() loop_optimization (before)
-  /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
-  //
-  /// CHECK-START: void Main.deadSingleLoop() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  static void deadSingleLoopN(int n) {
-    for (int i = 0; i < n; i++) {
+    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (before)
+    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
+    //
+    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    static void deadSingleLoop() {
+        for (int i = 0; i < 4; i++) {
+        }
     }
-  }
-
-  /// CHECK-START: void Main.potentialInfiniteLoop(int) loop_optimization (before)
-  /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
-  //
-  /// CHECK-START: void Main.potentialInfiniteLoop(int) loop_optimization (after)
-  /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
-  static void potentialInfiniteLoop(int n) {
-    for (int i = 0; i <= n; i++) {  // loops forever when n = MAX_INT
+
+    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (before)
+    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
+    //
+    /// CHECK-START: void Main.deadSingleLoop() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    static void deadSingleLoopN(int n) {
+        for (int i = 0; i < n; i++) {
+        }
     }
-  }
-
-  /// CHECK-START: void Main.deadNestedLoops() loop_optimization (before)
-  /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi loop:{{B\d+}}      outer_loop:<<Loop>>
-  //
-  /// CHECK-START: void Main.deadNestedLoops() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  static void deadNestedLoops() {
-    for (int i = 0; i < 4; i++) {
-      for (int j = 0; j < 4; j++) {
-      }
+
+    /// CHECK-START: void Main.potentialInfiniteLoop(int) loop_optimization (before)
+    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
+    //
+    /// CHECK-START: void Main.potentialInfiniteLoop(int) loop_optimization (after)
+    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
+    static void potentialInfiniteLoop(int n) {
+        for (int i = 0; i <= n; i++) {  // loops forever when n = MAX_INT
+        }
     }
-  }
-
-  /// CHECK-START: void Main.deadNestedAndFollowingLoops() loop_optimization (before)
-  /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
-  /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop2>>
-  /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop2>>
-  /// CHECK-DAG: Phi loop:<<Loop3:B\d+>> outer_loop:<<Loop1>>
-  /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop3>>
-  /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:none
-  //
-  /// CHECK-START: void Main.deadNestedAndFollowingLoops() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  static void deadNestedAndFollowingLoops() {
-    for (int i = 0; i < 4; i++) {
-      for (int j = 0; j < 4; j++) {
-        for (int k = 0; k < 4; k++) {
+
+    /// CHECK-START: void Main.deadNestedLoops() loop_optimization (before)
+    /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi loop:{{B\d+}}      outer_loop:<<Loop>>
+    //
+    /// CHECK-START: void Main.deadNestedLoops() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    static void deadNestedLoops() {
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+            }
         }
-        for (int k = 0; k < 4; k++) {
+    }
+
+    /// CHECK-START: void Main.deadNestedAndFollowingLoops() loop_optimization (before)
+    /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
+    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop2>>
+    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop2>>
+    /// CHECK-DAG: Phi loop:<<Loop3:B\d+>> outer_loop:<<Loop1>>
+    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:<<Loop3>>
+    /// CHECK-DAG: Phi loop:{{B\d+}}       outer_loop:none
+    //
+    /// CHECK-START: void Main.deadNestedAndFollowingLoops() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    static void deadNestedAndFollowingLoops() {
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                for (int k = 0; k < 4; k++) {
+                }
+                for (int k = 0; k < 4; k++) {
+                }
+            }
+            for (int j = 0; j < 4; j++) {
+                for (int k = 0; k < 4; k++) {
+                }
+            }
         }
-      }
-      for (int j = 0; j < 4; j++) {
-        for (int k = 0; k < 4; k++) {
+        for (int i = 0; i < 4; i++) {
         }
-      }
-    }
-    for (int i = 0; i < 4; i++) {
-    }
-  }
-
-  /// CHECK-START: void Main.deadConditional(int) loop_optimization (before)
-  /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
-  //
-  /// CHECK-START: void Main.deadConditional(int) loop_optimization (after)
-  /// CHECK-NOT: Phi
-  public static void deadConditional(int n) {
-    int k = 0;
-    int m = 0;
-    for (int i = 0; i < n; i++) {
-      if (i == 3)
-        k = i;
-      else
-        m = i;
-    }
-  }
-
-  /// CHECK-START: void Main.deadConditionalCycle(int) loop_optimization (before)
-  /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
-  //
-  /// CHECK-START: void Main.deadConditionalCycle(int) loop_optimization (after)
-  /// CHECK-NOT: Phi
-  public static void deadConditionalCycle(int n) {
-    int k = 0;
-    int m = 0;
-    for (int i = 0; i < n; i++) {
-      if (i == 3)
-        k--;
-      else
-        m++;
     }
-  }
-
-
-  /// CHECK-START: void Main.deadInduction() loop_optimization (before)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  //
-  /// CHECK-START: void Main.deadInduction() loop_optimization (after)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  static void deadInduction() {
-    int dead = 0;
-    for (int i = 0; i < a.length; i++) {
-      a[i] = novec[2 * i] + 1;
-      dead += 5;
-    }
-  }
-
-  /// CHECK-START: void Main.deadManyInduction() loop_optimization (before)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  //
-  /// CHECK-START: void Main.deadManyInduction() loop_optimization (after)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  static void deadManyInduction() {
-    int dead1 = 0, dead2 = 1, dead3 = 3;
-    for (int i = 0; i < a.length; i++) {
-      dead1 += 5;
-      a[i] = novec[2 * i] + 2;
-      dead2 += 10;
-      dead3 += 100;
-    }
-  }
-
-  /// CHECK-START: void Main.deadSequence() loop_optimization (before)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  //
-  /// CHECK-START: void Main.deadSequence() loop_optimization (after)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  static void deadSequence() {
-    int dead = 0;
-    for (int i = 0; i < a.length; i++) {
-      a[i] = novec[2 * i] + 3;
-      // Increment value defined inside loop,
-      // but sequence itself not used anywhere.
-      dead += i;
+
+    /// CHECK-START: void Main.deadConditional(int) loop_optimization (before)
+    /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
+    //
+    /// CHECK-START: void Main.deadConditional(int) loop_optimization (after)
+    /// CHECK-NOT: Phi
+    public static void deadConditional(int n) {
+        int k = 0;
+        int m = 0;
+        for (int i = 0; i < n; i++) {
+            if (i == 3)
+                k = i;
+            else
+                m = i;
+        }
     }
-  }
-
-  /// CHECK-START: void Main.deadCycleWithException(int) loop_optimization (before)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-NOT: BoundsCheck
-  //
-  /// CHECK-START: void Main.deadCycleWithException(int) loop_optimization (after)
-  /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
-  /// CHECK-NOT: ArrayGet loop:<<Loop>>      outer_loop:none
-  static void deadCycleWithException(int k) {
-    int dead = 0;
-    for (int i = 0; i < a.length; i++) {
-      a[i] = novec[2 * i] + 4;
-      // Increment value of dead cycle may throw exception. Dynamic
-      // BCE takes care of the bounds check though, which enables
-      // removing the ArrayGet after removing the dead cycle.
-      dead += a[k];
+
+    /// CHECK-START: void Main.deadConditionalCycle(int) loop_optimization (before)
+    /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
+    //
+    /// CHECK-START: void Main.deadConditionalCycle(int) loop_optimization (after)
+    /// CHECK-NOT: Phi
+    public static void deadConditionalCycle(int n) {
+        int k = 0;
+        int m = 0;
+        for (int i = 0; i < n; i++) {
+            if (i == 3)
+                k--;
+            else
+                m++;
+        }
     }
-  }
-
-  /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedFormInductionUp() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 12395 loop:none
-  /// CHECK-DAG:               Return [<<Int>>]  loop:none
-  static int closedFormInductionUp() {
-    int closed = 12345;
-    for (int i = 0; i < 10; i++) {
-      closed += 5;
+
+
+    /// CHECK-START: void Main.deadInduction() loop_optimization (before)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    //
+    /// CHECK-START: void Main.deadInduction() loop_optimization (after)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    static void deadInduction() {
+        int dead = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[i] = novec[2 * i] + 1;
+            dead += 5;
+        }
     }
-    return closed;  // only needs last value
-  }
-
-  /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedFormInductionInAndDown(int) instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Par:i\d+>>  ParameterValue        loop:none
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant -50       loop:none
-  /// CHECK-DAG: <<Add:i\d+>>  Add [<<Int>>,<<Par>>] loop:none
-  /// CHECK-DAG:               Return [<<Add>>]      loop:none
-  static int closedFormInductionInAndDown(int closed) {
-    for (int i = 0; i < 10; i++) {
-      closed -= 5;
+
+    /// CHECK-START: void Main.deadManyInduction() loop_optimization (before)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    //
+    /// CHECK-START: void Main.deadManyInduction() loop_optimization (after)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    static void deadManyInduction() {
+        int dead1 = 0, dead2 = 1, dead3 = 3;
+        for (int i = 0; i < a.length; i++) {
+            dead1 += 5;
+            a[i] = novec[2 * i] + 2;
+            dead2 += 10;
+            dead3 += 100;
+        }
     }
-    return closed;  // only needs last value
-  }
-
-  /// CHECK-START: int Main.closedFormInductionTrivialIf() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Select            loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedFormInductionTrivialIf() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  /// CHECK-NOT:               Select
-  //
-  /// CHECK-START: int Main.closedFormInductionTrivialIf() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 81    loop:none
-  /// CHECK-DAG:               Return [<<Int>>]  loop:none
-  static int closedFormInductionTrivialIf() {
-    int closed = 11;
-    for (int i = 0; i < 10; i++) {
-      // Trivial if becomes trivial select at HIR level.
-      // Make sure this is still recognized as induction.
-      if (i < 5) {
-        closed += 7;
-      } else {
-        closed += 7;
-      }
+
+    /// CHECK-START: void Main.deadSequence() loop_optimization (before)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    //
+    /// CHECK-START: void Main.deadSequence() loop_optimization (after)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    static void deadSequence() {
+        int dead = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[i] = novec[2 * i] + 3;
+            // Increment value defined inside loop,
+            // but sequence itself not used anywhere.
+            dead += i;
+        }
     }
-    return closed;  // only needs last value
-  }
-
-  /// CHECK-START: int Main.closedFormNested() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
-  /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:<<Loop1>>
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedFormNested() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedFormNested() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 100  loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  static int closedFormNested() {
-    int closed = 0;
-    for (int i = 0; i < 10; i++) {
-      for (int j = 0; j < 10; j++) {
-        closed++;
-      }
+
+    /// CHECK-START: void Main.deadCycleWithException(int) loop_optimization (before)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-NOT: BoundsCheck
+    //
+    /// CHECK-START: void Main.deadCycleWithException(int) loop_optimization (after)
+    /// CHECK-DAG: Phi      loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-NOT: Phi      loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: ArrayGet loop:<<Loop>>      outer_loop:none
+    /// CHECK-NOT: ArrayGet loop:<<Loop>>      outer_loop:none
+    static void deadCycleWithException(int k) {
+        int dead = 0;
+        for (int i = 0; i < a.length; i++) {
+            a[i] = novec[2 * i] + 4;
+            // Increment value of dead cycle may throw exception. Dynamic
+            // BCE takes care of the bounds check though, which enables
+            // removing the ArrayGet after removing the dead cycle.
+            dead += a[k];
+        }
     }
-    return closed;  // only needs last-value
-  }
-
-  /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
-  /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:<<Loop1>>
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedFormNestedAlt() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 15082 loop:none
-  /// CHECK-DAG:               Return [<<Int>>]  loop:none
-  static int closedFormNestedAlt() {
-    int closed = 12345;
-    for (int i = 0; i < 17; i++) {
-      for (int j = 0; j < 23; j++) {
-        closed += 7;
-      }
+
+    /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedFormInductionUp() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 12395 loop:none
+    /// CHECK-DAG:               Return [<<Int>>]  loop:none
+    static int closedFormInductionUp() {
+        int closed = 12345;
+        for (int i = 0; i < 10; i++) {
+            closed += 5;
+        }
+        return closed;  // only needs last value
     }
-    return closed;  // only needs last-value
-  }
-
-  // TODO: taken test around closed form?
-  static int closedFormInductionUpN(int n) {
-    int closed = 12345;
-    for (int i = 0; i < n; i++) {
-      closed += 5;
+
+    /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedFormInductionInAndDown(int) instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Par:i\d+>>  ParameterValue        loop:none
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant -50       loop:none
+    /// CHECK-DAG: <<Add:i\d+>>  Add [<<Int>>,<<Par>>] loop:none
+    /// CHECK-DAG:               Return [<<Add>>]      loop:none
+    static int closedFormInductionInAndDown(int closed) {
+        for (int i = 0; i < 10; i++) {
+            closed -= 5;
+        }
+        return closed;  // only needs last value
     }
-    return closed;  // only needs last value
-  }
 
-  // TODO: taken test around closed form?
-  static int closedFormInductionInAndDownN(int closed, int n) {
-    for (int i = 0; i < n; i++) {
-      closed -= 5;
+    /// CHECK-START: int Main.closedFormInductionTrivialIf() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Select            loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedFormInductionTrivialIf() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    /// CHECK-NOT:               Select
+    //
+    /// CHECK-START: int Main.closedFormInductionTrivialIf() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 81    loop:none
+    /// CHECK-DAG:               Return [<<Int>>]  loop:none
+    static int closedFormInductionTrivialIf() {
+        int closed = 11;
+        for (int i = 0; i < 10; i++) {
+            // Trivial if becomes trivial select at HIR level.
+            // Make sure this is still recognized as induction.
+            if (i < 5) {
+                closed += 7;
+            } else {
+                closed += 7;
+            }
+        }
+        return closed;  // only needs last value
     }
-    return closed;  // only needs last value
-  }
-
-  // TODO: move closed form even further out?
-  static int closedFormNestedN(int n) {
-    int closed = 0;
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < 10; j++) {
-        closed++;
-      }
+
+    /// CHECK-START: int Main.closedFormNested() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
+    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:<<Loop1>>
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedFormNested() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedFormNested() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 100  loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    static int closedFormNested() {
+        int closed = 0;
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                closed++;
+            }
+        }
+        return closed;  // only needs last-value
     }
-    return closed;  // only needs last-value
-  }
-
-  // TODO: move closed form even further out?
-  static int closedFormNestedNAlt(int n) {
-    int closed = 12345;
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < 23; j++) {
-        closed += 7;
-      }
+
+    /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
+    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:<<Loop1>>
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedFormNestedAlt() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 15082 loop:none
+    /// CHECK-DAG:               Return [<<Int>>]  loop:none
+    static int closedFormNestedAlt() {
+        int closed = 12345;
+        for (int i = 0; i < 17; i++) {
+            for (int j = 0; j < 23; j++) {
+                closed += 7;
+            }
+        }
+        return closed;  // only needs last-value
     }
-    return closed;  // only needs last-value
-  }
-
-  // TODO: move closed form even further out?
-  static int closedFormNestedMN(int m, int n) {
-    int closed = 0;
-    for (int i = 0; i < m; i++) {
-      for (int j = 0; j < n; j++) {
-        closed++;
-      }
+
+    // TODO: taken test around closed form?
+    static int closedFormInductionUpN(int n) {
+        int closed = 12345;
+        for (int i = 0; i < n; i++) {
+            closed += 5;
+        }
+        return closed;  // only needs last value
     }
-    return closed;  // only needs last-value
-  }
-
-  // TODO: move closed form even further out?
-  static int closedFormNestedMNAlt(int m, int n) {
-    int closed = 12345;
-    for (int i = 0; i < m; i++) {
-      for (int j = 0; j < n; j++) {
-        closed += 7;
-      }
+
+    // TODO: taken test around closed form?
+    static int closedFormInductionInAndDownN(int closed, int n) {
+        for (int i = 0; i < n; i++) {
+            closed -= 5;
+        }
+        return closed;  // only needs last value
     }
-    return closed;  // only needs last-value
-  }
-
-  /// CHECK-START: int Main.mainIndexReturned() loop_optimization (before)
-  /// CHECK-DAG: <<Phi:i\d+>> Phi              loop:{{B\d+}} outer_loop:none
-  /// CHECK-DAG:              Return [<<Phi>>] loop:none
-  //
-  /// CHECK-START: int Main.mainIndexReturned() loop_optimization (after)
-  /// CHECK-NOT:              Phi
-  //
-  /// CHECK-START: int Main.mainIndexReturned() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  static int mainIndexReturned() {
-    int i;
-    for (i = 0; i < 10; i++);
-    return i;
-  }
-
-  /// CHECK-START: int Main.periodicReturned9() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.periodicReturned9() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.periodicReturned9() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 1    loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  static int periodicReturned9() {
-    int k = 0;
-    for (int i = 0; i < 9; i++) {
-      k = 1 - k;
+
+    // TODO: move closed form even further out?
+    static int closedFormNestedN(int n) {
+        int closed = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < 10; j++) {
+                closed++;
+            }
+        }
+        return closed;  // only needs last-value
     }
-    return k;
-  }
-
-  /// CHECK-START: int Main.periodicReturned10() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.periodicReturned10() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.periodicReturned10() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  static int periodicReturned10() {
-    int k = 0;
-    for (int i = 0; i < 10; i++) {
-      k = 1 - k;
+
+    // TODO: move closed form even further out?
+    static int closedFormNestedNAlt(int n) {
+        int closed = 12345;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < 23; j++) {
+                closed += 7;
+            }
+        }
+        return closed;  // only needs last-value
     }
-    return k;
-  }
-
-  /// CHECK-START: int Main.getSum21() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: int Main.getSum21() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.getSum21() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 21   loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static int getSum21() {
-    int k = 0;
-    int sum = 0;
-    for (int i = 0; i < 6; i++) {
-      k++;
-      sum += k;
+
+    // TODO: move closed form even further out?
+    static int closedFormNestedMN(int m, int n) {
+        int closed = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                closed++;
+            }
+        }
+        return closed;  // only needs last-value
     }
-    return sum;
-  }
-
-  // Ensure double induction does not "overshoot" the subscript range.
-  private static int getIncr2(int[] arr) {
-    for (int i = 0; i < 12; ) {
-      arr[i++] = 30;
-      arr[i++] = 29;
+
+    // TODO: move closed form even further out?
+    static int closedFormNestedMNAlt(int m, int n) {
+        int closed = 12345;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                closed += 7;
+            }
+        }
+        return closed;  // only needs last-value
     }
-    int sum = 0;
-    for (int i = 0; i < 12; i++) {
-      sum += arr[i];
+
+    /// CHECK-START: int Main.mainIndexReturned() loop_optimization (before)
+    /// CHECK-DAG: <<Phi:i\d+>> Phi              loop:{{B\d+}} outer_loop:none
+    /// CHECK-DAG:              Return [<<Phi>>] loop:none
+    //
+    /// CHECK-START: int Main.mainIndexReturned() loop_optimization (after)
+    /// CHECK-NOT:              Phi
+    //
+    /// CHECK-START: int Main.mainIndexReturned() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    static int mainIndexReturned() {
+        int i;
+        for (i = 0; i < 10; i++);
+        return i;
     }
-    return sum;
-  }
-
-  // TODO: handle as closed/empty eventually?
-  static int mainIndexReturnedN(int n) {
-    int i;
-    for (i = 0; i < n; i++);
-    return i;
-  }
-
-  // TODO: handle as closed/empty eventually?
-  static int mainIndexShort1(short s) {
-    int i = 0;
-    for (i = 0; i < s; i++) { }
-    return i;
-  }
-
-  // TODO: handle as closed/empty eventually?
-  static int mainIndexShort2(short s) {
-    int i = 0;
-    for (i = 0; s > i; i++) { }
-    return i;
-  }
-
-  /// CHECK-START: int Main.periodicReturnedN(int) loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.periodicReturnedN(int) loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  static int periodicReturnedN(int n) {
-    int k = 0;
-    for (int i = 0; i < n; i++) {
-      k = 1 - k;
+
+    /// CHECK-START: int Main.periodicReturned9() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.periodicReturned9() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.periodicReturned9() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 1    loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    static int periodicReturned9() {
+        int k = 0;
+        for (int i = 0; i < 9; i++) {
+            k = 1 - k;
+        }
+        return k;
     }
-    return k;
-  }
-
-  // If ever replaced by closed form, last value should be correct!
-  private static int getSumN(int n) {
-    int k = 0;
-    int sum = 0;
-    for (int i = 0; i < n; i++) {
-      k++;
-      sum += k;
+
+    /// CHECK-START: int Main.periodicReturned10() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.periodicReturned10() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.periodicReturned10() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    static int periodicReturned10() {
+        int k = 0;
+        for (int i = 0; i < 10; i++) {
+            k = 1 - k;
+        }
+        return k;
     }
-    return sum;
-  }
-
-  // If ever replaced by closed form, last value should be correct!
-  private static int closedTwice() {
-    int closed = 0;
-    for (int i = 0; i < 10; i++) {
-      closed++;
+
+    /// CHECK-START: int Main.getSum21() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: int Main.getSum21() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.getSum21() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 21   loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static int getSum21() {
+        int k = 0;
+        int sum = 0;
+        for (int i = 0; i < 6; i++) {
+            k++;
+            sum += k;
+        }
+        return sum;
     }
-    // Closed form of first loop defines trip count of second loop.
-    int other_closed = 0;
-    for (int i = 0; i < closed; i++) {
-      other_closed++;
+
+    // Ensure double induction does not "overshoot" the subscript range.
+    private static int getIncr2(int[] arr) {
+        for (int i = 0; i < 12; ) {
+            arr[i++] = 30;
+            arr[i++] = 29;
+        }
+        int sum = 0;
+        for (int i = 0; i < 12; i++) {
+            sum += arr[i];
+        }
+        return sum;
     }
-    return other_closed;
-  }
-
-  /// CHECK-START: int Main.closedFeed() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi3>>] loop:none
-  /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>"
-  //
-  /// CHECK-START: int Main.closedFeed() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedFeed() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 20   loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static int closedFeed() {
-    int closed = 0;
-    for (int i = 0; i < 10; i++) {
-      closed++;
+
+    // TODO: handle as closed/empty eventually?
+    static int mainIndexReturnedN(int n) {
+        int i;
+        for (i = 0; i < n; i++);
+        return i;
     }
-    // Closed form of first loop feeds into initial value of second loop,
-    // used when generating closed form for the latter.
-    for (int i = 0; i < 10; i++) {
-      closed++;
+
+    // TODO: handle as closed/empty eventually?
+    static int mainIndexShort1(short s) {
+        int i = 0;
+        for (i = 0; i < s; i++) { }
+        return i;
     }
-    return closed;
-  }
-
-  /// CHECK-START: int Main.closedLargeUp() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedLargeUp() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedLargeUp() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant -10  loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static int closedLargeUp() {
-    int closed = 0;
-    for (int i = 0; i < 10; i++) {
-      closed += 0x7fffffff;
+
+    // TODO: handle as closed/empty eventually?
+    static int mainIndexShort2(short s) {
+        int i = 0;
+        for (i = 0; s > i; i++) { }
+        return i;
     }
-    return closed;
-  }
-
-  /// CHECK-START: int Main.closedLargeDown() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedLargeDown() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedLargeDown() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static int closedLargeDown() {
-    int closed = 0;
-    for (int i = 0; i < 10; i++) {
-      closed -= 0x7fffffff;
+
+    /// CHECK-START: int Main.periodicReturnedN(int) loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.periodicReturnedN(int) loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    static int periodicReturnedN(int n) {
+        int k = 0;
+        for (int i = 0; i < n; i++) {
+            k = 1 - k;
+        }
+        return k;
     }
-    return closed;
-  }
-
-  // Checks that we do not loop optimize if the calculation of the trip count would overflow.
-  /// CHECK-START: int Main.closedLinearStepOverflow() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedLinearStepOverflow() loop_optimization (after)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  private static int closedLinearStepOverflow() {
-    int closed = 0;
-    // Note that this isn't a "one-off" error. We are using MIN and MAX to make sure we overflow.
-    for (int i = Integer.MIN_VALUE; i < (Integer.MAX_VALUE - 80); i += 79) {
-      closed++;
+
+    // If ever replaced by closed form, last value should be correct!
+    private static int getSumN(int n) {
+        int k = 0;
+        int sum = 0;
+        for (int i = 0; i < n; i++) {
+            k++;
+            sum += k;
+        }
+        return sum;
     }
-    return closed;
-  }
-
-  // Since we cannot guarantee that the start/end wouldn't overflow we do not perform loop
-  // optimization.
-  /// CHECK-START: int Main.$inline$closedByParameters(int, int) loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.$inline$closedByParameters(int, int) loop_optimization (after)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  private static int $inline$closedByParameters(int start, int end) {
-    int closed = 0;
-    for (int i = start; i < end; i++) {
-      closed++;
+
+    // If ever replaced by closed form, last value should be correct!
+    private static int closedTwice() {
+        int closed = 0;
+        for (int i = 0; i < 10; i++) {
+            closed++;
+        }
+        // Closed form of first loop defines trip count of second loop.
+        int other_closed = 0;
+        for (int i = 0; i < closed; i++) {
+            other_closed++;
+        }
+        return other_closed;
     }
-    return closed;
-  }
-
-  // Since we are inlining `closedByParameters` we know that the parameters are fixed and
-  // therefore we can perform loop optimization.
-  /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.closedByParametersWithInline() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static int closedByParametersWithInline() {
-    return $inline$closedByParameters(0, 10);
-  }
-
-  /// CHECK-START: int Main.waterFall() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop3:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop4:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi5:i\d+>> Phi               loop:<<Loop5:B\d+>> outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi5>>] loop:none
-  //
-  /// CHECK-START: int Main.waterFall() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: int Main.waterFall() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 50   loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static int waterFall() {
-    int i = 0;
-    for (; i < 10; i++);
-    for (; i < 20; i++);
-    for (; i < 30; i++);
-    for (; i < 40; i++);
-    for (; i < 50; i++);
-    return i;  // this should become just 50
-  }
-
-  /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom1() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static boolean periodicBoolIdiom1() {
-    boolean x = true;
-    for (int i = 0; i < 7; i++) {
-      x = !x;
+
+    /// CHECK-START: int Main.closedFeed() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop1>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop2>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi3>>] loop:none
+    /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>"
+    //
+    /// CHECK-START: int Main.closedFeed() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedFeed() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 20   loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static int closedFeed() {
+        int closed = 0;
+        for (int i = 0; i < 10; i++) {
+            closed++;
+        }
+        // Closed form of first loop feeds into initial value of second loop,
+        // used when generating closed form for the latter.
+        for (int i = 0; i < 10; i++) {
+            closed++;
+        }
+        return closed;
     }
-    return x;
-  }
-
-  /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom2() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static boolean periodicBoolIdiom2() {
-    boolean x = true;
-    for (int i = 0; i < 7; i++) {
-      x = (x != true);
+
+    /// CHECK-START: int Main.closedLargeUp() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedLargeUp() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedLargeUp() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant -10  loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static int closedLargeUp() {
+        int closed = 0;
+        for (int i = 0; i < 10; i++) {
+            closed += 0x7fffffff;
+        }
+        return closed;
     }
-    return x;
-  }
-
-  /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi1>>] loop:none
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom3() instruction_simplifier$after_bce (after)
-  /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
-  /// CHECK-DAG:               Return [<<Int>>] loop:none
-  private static boolean periodicBoolIdiom3() {
-    boolean x = true;
-    for (int i = 0; i < 7; i++) {
-      x = (x == false);
+
+    /// CHECK-START: int Main.closedLargeDown() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedLargeDown() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedLargeDown() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static int closedLargeDown() {
+        int closed = 0;
+        for (int i = 0; i < 10; i++) {
+            closed -= 0x7fffffff;
+        }
+        return closed;
     }
-    return x;
-  }
-
-  /// CHECK-START: boolean Main.periodicBoolIdiom1N(boolean, int) loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom1N(boolean, int) loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  private static boolean periodicBoolIdiom1N(boolean x, int n) {
-    for (int i = 0; i < n; i++) {
-      x = !x;
+
+    // Checks that we do not loop optimize if the calculation of the trip count would overflow.
+    /// CHECK-START: int Main.closedLinearStepOverflow() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedLinearStepOverflow() loop_optimization (after)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    private static int closedLinearStepOverflow() {
+        int closed = 0;
+        // Note that this isn't a "one-off" error.
+        // We are using MIN and MAX to make sure we overflow.
+        for (int i = Integer.MIN_VALUE; i < (Integer.MAX_VALUE - 80); i += 79) {
+            closed++;
+        }
+        return closed;
     }
-    return x;
-  }
-
-  /// CHECK-START: boolean Main.periodicBoolIdiom2N(boolean, int) loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom2N(boolean, int) loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  private static boolean periodicBoolIdiom2N(boolean x, int n) {
-    for (int i = 0; i < n; i++) {
-      x = (x != true);
+
+    // Since we cannot guarantee that the start/end wouldn't overflow we do not perform loop
+    // optimization.
+    /// CHECK-START: int Main.$inline$closedByParameters(int, int) loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.$inline$closedByParameters(int, int) loop_optimization (after)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    private static int $inline$closedByParameters(int start, int end) {
+        int closed = 0;
+        for (int i = start; i < end; i++) {
+            closed++;
+        }
+        return closed;
     }
-    return x;
-  }
-
-  /// CHECK-START: boolean Main.periodicBoolIdiom3N(boolean, int) loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: boolean Main.periodicBoolIdiom3N(boolean, int) loop_optimization (after)
-  /// CHECK-NOT:               Phi
-  private static boolean periodicBoolIdiom3N(boolean x, int n) {
-    for (int i = 0; i < n; i++) {
-      x = (x == false);
+
+    // Since we are inlining `closedByParameters` we know that the parameters are fixed and
+    // therefore we can perform loop optimization.
+    /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.closedByParametersWithInline() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static int closedByParametersWithInline() {
+        return $inline$closedByParameters(0, 10);
     }
-    return x;
-  }
-
-  /// CHECK-START: float Main.periodicFloat10() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: float Main.periodicFloat10() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  //
-  /// CHECK-START: float Main.periodicFloat10() loop_optimization (after)
-  /// CHECK-DAG: <<Float:f\d+>>  FloatConstant 2    loop:none
-  /// CHECK-DAG:                 Return [<<Float>>] loop:none
-  private static float periodicFloat10() {
-    float r = 4.5f;
-    float s = 2.0f;
-    float t = -1.0f;
-    for (int i = 0; i < 10; i++) {
-      float tmp = t; t = r; r = s; s = tmp;
+
+    /// CHECK-START: int Main.waterFall() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop1:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop2:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi3:i\d+>> Phi               loop:<<Loop3:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi4:i\d+>> Phi               loop:<<Loop4:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi5:i\d+>> Phi               loop:<<Loop5:B\d+>> outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi5>>] loop:none
+    //
+    /// CHECK-START: int Main.waterFall() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: int Main.waterFall() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 50   loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static int waterFall() {
+        int i = 0;
+        for (; i < 10; i++);
+        for (; i < 20; i++);
+        for (; i < 30; i++);
+        for (; i < 40; i++);
+        for (; i < 50; i++);
+        return i;  // this should become just 50
     }
-    return r;
-  }
-
-  /// CHECK-START: float Main.periodicFloat11() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: float Main.periodicFloat11() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  //
-  /// CHECK-START: float Main.periodicFloat11() loop_optimization (after)
-  /// CHECK-DAG: <<Float:f\d+>>  FloatConstant -1   loop:none
-  /// CHECK-DAG:                 Return [<<Float>>] loop:none
-  private static float periodicFloat11() {
-    float r = 4.5f;
-    float s = 2.0f;
-    float t = -1.0f;
-    for (int i = 0; i < 11; i++) {
-      float tmp = t; t = r; r = s; s = tmp;
+
+    /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom1() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static boolean periodicBoolIdiom1() {
+        boolean x = true;
+        for (int i = 0; i < 7; i++) {
+            x = !x;
+        }
+        return x;
     }
-    return r;
-  }
-
-  /// CHECK-START: float Main.periodicFloat12() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  /// CHECK-DAG:               Return [<<Phi2>>] loop:none
-  //
-  /// CHECK-START: float Main.periodicFloat12() loop_optimization (after)
-  /// CHECK-NOT: Phi
-  //
-  /// CHECK-START: float Main.periodicFloat12() loop_optimization (after)
-  /// CHECK-DAG: <<Float:f\d+>>  FloatConstant 4.5  loop:none
-  /// CHECK-DAG:                 Return [<<Float>>] loop:none
-  private static float periodicFloat12() {
-    float r = 4.5f;
-    float s = 2.0f;
-    float t = -1.0f;
-    for (int i = 0; i < 12; i++) {
-      float tmp = t; t = r; r = s; s = tmp;
+
+    /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom2() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static boolean periodicBoolIdiom2() {
+        boolean x = true;
+        for (int i = 0; i < 7; i++) {
+            x = (x != true);
+        }
+        return x;
     }
-    return r;
-  }
-
-  private static int exceptionExitBeforeAdd() {
-    int k = 0;
-    try {
-      for (int i = 0; i < 10; i++) {
-        a[i] = 0;
-        k += 10;  // increment last
-      }
-    } catch(Exception e) {
-      // Flag error by returning current
-      // value of k negated.
-      return -k-1;
+
+    /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi1>>] loop:none
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom3() instruction_simplifier$after_bce (after)
+    /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
+    /// CHECK-DAG:               Return [<<Int>>] loop:none
+    private static boolean periodicBoolIdiom3() {
+        boolean x = true;
+        for (int i = 0; i < 7; i++) {
+            x = (x == false);
+        }
+        return x;
     }
-    return k;
-  }
-
-  private static int exceptionExitAfterAdd() {
-    int k = 0;
-    try {
-      for (int i = 0; i < 10; i++) {
-        k += 10;  // increment first
-        a[i] = 0;
-      }
-    } catch(Exception e) {
-      // Flag error by returning current
-      // value of k negated.
-      return -k-1;
+
+    /// CHECK-START: boolean Main.periodicBoolIdiom1N(boolean, int) loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom1N(boolean, int) loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    private static boolean periodicBoolIdiom1N(boolean x, int n) {
+        for (int i = 0; i < n; i++) {
+            x = !x;
+        }
+        return x;
     }
-    return k;
-  }
-
-  /// CHECK-START: long Main.closedLinearInductionUnmatchedTypesNotOptimized() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:j\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  //
-  /// CHECK-START: long Main.closedLinearInductionUnmatchedTypesNotOptimized() loop_optimization (after)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  /// CHECK-DAG: <<Phi2:j\d+>> Phi               loop:<<Loop>>      outer_loop:none
-  private static long closedLinearInductionUnmatchedTypesNotOptimized() {
-      long sum = 0;
-      for (int i = 0; i < 10; ++i) {
-          ++sum;
-      }
-      return sum;
-  }
-
-  /// CHECK-START: short Main.closedLinearInductionNarrowingNotOptimized() loop_optimization (before)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  //
-  /// CHECK-START: short Main.closedLinearInductionNarrowingNotOptimized() loop_optimization (after)
-  /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
-  private static short closedLinearInductionNarrowingNotOptimized() {
-      short i = 0;
-      for (; i < 10; ++i);
-      return i;
-  }
-
-  public static void main(String[] args) {
-    deadSingleLoop();
-    deadSingleLoopN(4);
-    potentialInfiniteLoop(4);
-    deadNestedLoops();
-    deadNestedAndFollowingLoops();
-    deadConditional(4);
-    deadConditionalCycle(4);
-
-    deadInduction();
-    for (int i = 0; i < a.length; i++) {
-      expectEquals(1, a[i]);
+
+    /// CHECK-START: boolean Main.periodicBoolIdiom2N(boolean, int) loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom2N(boolean, int) loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    private static boolean periodicBoolIdiom2N(boolean x, int n) {
+        for (int i = 0; i < n; i++) {
+            x = (x != true);
+        }
+        return x;
     }
-    deadManyInduction();
-    for (int i = 0; i < a.length; i++) {
-      expectEquals(2, a[i]);
+
+    /// CHECK-START: boolean Main.periodicBoolIdiom3N(boolean, int) loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:i\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: boolean Main.periodicBoolIdiom3N(boolean, int) loop_optimization (after)
+    /// CHECK-NOT:               Phi
+    private static boolean periodicBoolIdiom3N(boolean x, int n) {
+        for (int i = 0; i < n; i++) {
+            x = (x == false);
+        }
+        return x;
     }
-    deadSequence();
-    for (int i = 0; i < a.length; i++) {
-      expectEquals(3, a[i]);
+
+    /// CHECK-START: float Main.periodicFloat10() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: float Main.periodicFloat10() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    //
+    /// CHECK-START: float Main.periodicFloat10() loop_optimization (after)
+    /// CHECK-DAG: <<Float:f\d+>>  FloatConstant 2    loop:none
+    /// CHECK-DAG:                 Return [<<Float>>] loop:none
+    private static float periodicFloat10() {
+        float r = 4.5f;
+        float s = 2.0f;
+        float t = -1.0f;
+        for (int i = 0; i < 10; i++) {
+            float tmp = t;
+            t = r;
+            r = s;
+            s = tmp;
+        }
+        return r;
     }
-    try {
-      deadCycleWithException(-1);
-      throw new Error("Expected: IOOB exception");
-    } catch (IndexOutOfBoundsException e) {
+
+    /// CHECK-START: float Main.periodicFloat11() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: float Main.periodicFloat11() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    //
+    /// CHECK-START: float Main.periodicFloat11() loop_optimization (after)
+    /// CHECK-DAG: <<Float:f\d+>>  FloatConstant -1   loop:none
+    /// CHECK-DAG:                 Return [<<Float>>] loop:none
+    private static float periodicFloat11() {
+        float r = 4.5f;
+        float s = 2.0f;
+        float t = -1.0f;
+        for (int i = 0; i < 11; i++) {
+            float tmp = t;
+            t = r;
+            r = s;
+            s = tmp;
+        }
+        return r;
     }
-    for (int i = 0; i < a.length; i++) {
-      expectEquals(i == 0 ? 4 : 3, a[i]);
+
+    /// CHECK-START: float Main.periodicFloat12() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi3:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG: <<Phi4:f\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    /// CHECK-DAG:               Return [<<Phi2>>] loop:none
+    //
+    /// CHECK-START: float Main.periodicFloat12() loop_optimization (after)
+    /// CHECK-NOT: Phi
+    //
+    /// CHECK-START: float Main.periodicFloat12() loop_optimization (after)
+    /// CHECK-DAG: <<Float:f\d+>>  FloatConstant 4.5  loop:none
+    /// CHECK-DAG:                 Return [<<Float>>] loop:none
+    private static float periodicFloat12() {
+        float r = 4.5f;
+        float s = 2.0f;
+        float t = -1.0f;
+        for (int i = 0; i < 12; i++) {
+            float tmp = t;
+            t = r;
+            r = s;
+            s = tmp;
+        }
+        return r;
     }
-    deadCycleWithException(0);
-    for (int i = 0; i < a.length; i++) {
-      expectEquals(4, a[i]);
+
+    private static int exceptionExitBeforeAdd() {
+        int k = 0;
+        try {
+            for (int i = 0; i < 10; i++) {
+                a[i] = 0;
+                k += 10;  // increment last
+            }
+        } catch (Exception e) {
+            // Flag error by returning current
+            // value of k negated.
+            return -k - 1;
+        }
+        return k;
     }
 
-    expectEquals(12395, closedFormInductionUp());
-    expectEquals(12295, closedFormInductionInAndDown(12345));
-    expectEquals(81, closedFormInductionTrivialIf());
-    expectEquals(10 * 10, closedFormNested());
-    expectEquals(12345 + 17 * 23 * 7, closedFormNestedAlt());
-    for (int n = -4; n < 10; n++) {
-      int tc = (n <= 0) ? 0 : n;
-      expectEquals(12345 + tc * 5, closedFormInductionUpN(n));
-      expectEquals(12345 - tc * 5, closedFormInductionInAndDownN(12345, n));
-      expectEquals(tc * 10, closedFormNestedN(n));
-      expectEquals(12345 + tc * 23 * 7, closedFormNestedNAlt(n));
-      expectEquals(tc * (tc + 1), closedFormNestedMN(n, n + 1));
-      expectEquals(12345 + tc * (tc + 1) * 7, closedFormNestedMNAlt(n, n + 1));
+    private static int exceptionExitAfterAdd() {
+        int k = 0;
+        try {
+            for (int i = 0; i < 10; i++) {
+                k += 10;  // increment first
+                a[i] = 0;
+            }
+        } catch (Exception e) {
+            // Flag error by returning current
+            // value of k negated.
+            return -k - 1;
+        }
+        return k;
     }
 
-    expectEquals(10, mainIndexReturned());
-    expectEquals(1, periodicReturned9());
-    expectEquals(0, periodicReturned10());
-    expectEquals(21, getSum21());
-    expectEquals(354, getIncr2(new int[12]));
-    for (int n = -4; n < 4; n++) {
-      int tc = (n <= 0) ? 0 : n;
-      expectEquals(tc, mainIndexReturnedN(n));
-      expectEquals(tc, mainIndexShort1((short) n));
-      expectEquals(tc, mainIndexShort2((short) n));
-      expectEquals(tc & 1, periodicReturnedN(n));
-      expectEquals((tc * (tc + 1)) / 2, getSumN(n));
+    /// CHECK-START: long Main.closedLinearInductionUnmatchedTypesNotOptimized() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:j\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    //
+    /// CHECK-START: long Main.closedLinearInductionUnmatchedTypesNotOptimized() loop_optimization (after)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    /// CHECK-DAG: <<Phi2:j\d+>> Phi               loop:<<Loop>>      outer_loop:none
+    private static long closedLinearInductionUnmatchedTypesNotOptimized() {
+        long sum = 0;
+        for (int i = 0; i < 10; ++i) {
+            ++sum;
+        }
+        return sum;
     }
 
-    expectEquals(10, closedTwice());
-    expectEquals(20, closedFeed());
-    expectEquals(-10, closedLargeUp());
-    expectEquals(10, closedLargeDown());
-    expectEquals(54366674, closedLinearStepOverflow());
-    expectEquals(10, $inline$closedByParameters(0, 10));
-    expectEquals(10, closedByParametersWithInline());
-    expectEquals(50, waterFall());
-
-    expectEquals(false, periodicBoolIdiom1());
-    expectEquals(false, periodicBoolIdiom2());
-    expectEquals(false, periodicBoolIdiom3());
-    for (int n = -4; n < 10; n++) {
-      int tc = (n <= 0) ? 0 : n;
-      boolean even = (tc & 1) == 0;
-      expectEquals(even, periodicBoolIdiom1N(true, n));
-      expectEquals(!even, periodicBoolIdiom1N(false, n));
-      expectEquals(even, periodicBoolIdiom2N(true, n));
-      expectEquals(!even, periodicBoolIdiom2N(false, n));
-      expectEquals(even, periodicBoolIdiom3N(true, n));
-      expectEquals(!even, periodicBoolIdiom3N(false, n));
+    /// CHECK-START: short Main.closedLinearInductionNarrowingNotOptimized() loop_optimization (before)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    //
+    /// CHECK-START: short Main.closedLinearInductionNarrowingNotOptimized() loop_optimization (after)
+    /// CHECK-DAG: <<Phi1:i\d+>> Phi               loop:<<Loop:B\d+>> outer_loop:none
+    private static short closedLinearInductionNarrowingNotOptimized() {
+        short i = 0;
+        for (; i < 10; ++i);
+        return i;
     }
 
-    expectEquals( 2.0f, periodicFloat10());
-    expectEquals(-1.0f, periodicFloat11());
-    expectEquals( 4.5f, periodicFloat12());
+    public static void main(String[] args) {
+        deadSingleLoop();
+        deadSingleLoopN(4);
+        potentialInfiniteLoop(4);
+        deadNestedLoops();
+        deadNestedAndFollowingLoops();
+        deadConditional(4);
+        deadConditionalCycle(4);
+
+        deadInduction();
+        for (int i = 0; i < a.length; i++) {
+            expectEquals(1, a[i]);
+        }
+        deadManyInduction();
+        for (int i = 0; i < a.length; i++) {
+            expectEquals(2, a[i]);
+        }
+        deadSequence();
+        for (int i = 0; i < a.length; i++) {
+            expectEquals(3, a[i]);
+        }
+        try {
+            deadCycleWithException(-1);
+            throw new Error("Expected: IOOB exception");
+        } catch (IndexOutOfBoundsException e) {
+        }
+        for (int i = 0; i < a.length; i++) {
+            expectEquals(i == 0 ? 4 : 3, a[i]);
+        }
+        deadCycleWithException(0);
+        for (int i = 0; i < a.length; i++) {
+            expectEquals(4, a[i]);
+        }
+
+        expectEquals(12395, closedFormInductionUp());
+        expectEquals(12295, closedFormInductionInAndDown(12345));
+        expectEquals(81, closedFormInductionTrivialIf());
+        expectEquals(10 * 10, closedFormNested());
+        expectEquals(12345 + 17 * 23 * 7, closedFormNestedAlt());
+        for (int n = -4; n < 10; n++) {
+            int tc = (n <= 0) ? 0 : n;
+            expectEquals(12345 + tc * 5, closedFormInductionUpN(n));
+            expectEquals(12345 - tc * 5, closedFormInductionInAndDownN(12345, n));
+            expectEquals(tc * 10, closedFormNestedN(n));
+            expectEquals(12345 + tc * 23 * 7, closedFormNestedNAlt(n));
+            expectEquals(tc * (tc + 1), closedFormNestedMN(n, n + 1));
+            expectEquals(12345 + tc * (tc + 1) * 7, closedFormNestedMNAlt(n, n + 1));
+        }
 
-    expectEquals(100, exceptionExitBeforeAdd());
-    expectEquals(100, exceptionExitAfterAdd());
-    a = null;
-    expectEquals(-1, exceptionExitBeforeAdd());
-    expectEquals(-11, exceptionExitAfterAdd());
-    a = new int[4];
-    expectEquals(-41, exceptionExitBeforeAdd());
-    expectEquals(-51, exceptionExitAfterAdd());
+        expectEquals(10, mainIndexReturned());
+        expectEquals(1, periodicReturned9());
+        expectEquals(0, periodicReturned10());
+        expectEquals(21, getSum21());
+        expectEquals(354, getIncr2(new int[12]));
+        for (int n = -4; n < 4; n++) {
+            int tc = (n <= 0) ? 0 : n;
+            expectEquals(tc, mainIndexReturnedN(n));
+            expectEquals(tc, mainIndexShort1((short) n));
+            expectEquals(tc, mainIndexShort2((short) n));
+            expectEquals(tc & 1, periodicReturnedN(n));
+            expectEquals((tc * (tc + 1)) / 2, getSumN(n));
+        }
 
-    expectEquals(10, closedLinearInductionUnmatchedTypesNotOptimized());
-    expectEquals(10, closedLinearInductionNarrowingNotOptimized());
+        expectEquals(10, closedTwice());
+        expectEquals(20, closedFeed());
+        expectEquals(-10, closedLargeUp());
+        expectEquals(10, closedLargeDown());
+        expectEquals(54366674, closedLinearStepOverflow());
+        expectEquals(10, $inline$closedByParameters(0, 10));
+        expectEquals(10, closedByParametersWithInline());
+        expectEquals(50, waterFall());
+
+        expectEquals(false, periodicBoolIdiom1());
+        expectEquals(false, periodicBoolIdiom2());
+        expectEquals(false, periodicBoolIdiom3());
+        for (int n = -4; n < 10; n++) {
+            int tc = (n <= 0) ? 0 : n;
+            boolean even = (tc & 1) == 0;
+            expectEquals(even, periodicBoolIdiom1N(true, n));
+            expectEquals(!even, periodicBoolIdiom1N(false, n));
+            expectEquals(even, periodicBoolIdiom2N(true, n));
+            expectEquals(!even, periodicBoolIdiom2N(false, n));
+            expectEquals(even, periodicBoolIdiom3N(true, n));
+            expectEquals(!even, periodicBoolIdiom3N(false, n));
+        }
 
-    System.out.println("passed");
-  }
+        expectEquals( 2.0f, periodicFloat10());
+        expectEquals(-1.0f, periodicFloat11());
+        expectEquals( 4.5f, periodicFloat12());
 
-  private static void expectEquals(float expected, float result) {
-    if (expected != result) {
-      throw new Error("Expected: " + expected + ", found: " + result);
+        expectEquals(100, exceptionExitBeforeAdd());
+        expectEquals(100, exceptionExitAfterAdd());
+        a = null;
+        expectEquals(-1, exceptionExitBeforeAdd());
+        expectEquals(-11, exceptionExitAfterAdd());
+        a = new int[4];
+        expectEquals(-41, exceptionExitBeforeAdd());
+        expectEquals(-51, exceptionExitAfterAdd());
+
+        expectEquals(10, closedLinearInductionUnmatchedTypesNotOptimized());
+        expectEquals(10, closedLinearInductionNarrowingNotOptimized());
+
+        System.out.println("passed");
     }
-  }
 
-  private static void expectEquals(int expected, int result) {
-    if (expected != result) {
-      throw new Error("Expected: " + expected + ", found: " + result);
+    private static void expectEquals(float expected, float result) {
+        if (expected != result) {
+            throw new Error("Expected: " + expected + ", found: " + result);
+        }
     }
-  }
 
-  private static void expectEquals(boolean expected, boolean result) {
-    if (expected != result) {
-      throw new Error("Expected: " + expected + ", found: " + result);
+    private static void expectEquals(int expected, int result) {
+        if (expected != result) {
+            throw new Error("Expected: " + expected + ", found: " + result);
+        }
+    }
+
+    private static void expectEquals(boolean expected, boolean result) {
+        if (expected != result) {
+            throw new Error("Expected: " + expected + ", found: " + result);
+        }
     }
-  }
 }
diff --git a/test/619-checker-current-method/src/Main.java b/test/619-checker-current-method/src/Main.java
index d829370d74..3ab73fa6c5 100644
--- a/test/619-checker-current-method/src/Main.java
+++ b/test/619-checker-current-method/src/Main.java
@@ -15,19 +15,18 @@
  */
 
 public class Main {
+    // Check that there is no instruction storing to stack.
+    /// CHECK-START-X86: int Main.foo(int, int, int, int, int, int) disassembly (after)
+    /// CHECK-NOT:  mov [{{\w+}}], {{\w+}}
 
-  // Check that there is no instruction storing to stack.
-  /// CHECK-START-X86: int Main.foo(int, int, int, int, int, int) disassembly (after)
-  /// CHECK-NOT:  mov [{{\w+}}], {{\w+}}
-
-  // Use enough parameters to ensure we'll need a frame.
-  public static int foo(int a, int b, int c, int d, int e, int f) {
-    return a + b + c + d + e + f;
-  }
+    // Use enough parameters to ensure we'll need a frame.
+    public static int foo(int a, int b, int c, int d, int e, int f) {
+        return a + b + c + d + e + f;
+    }
 
-  public static void main(String[] args) {
-    if (foo(1, 2, 3, 4, 5, 6) != 21) {
-      throw new Error("Expected 21");
+    public static void main(String[] args) {
+        if (foo(1, 2, 3, 4, 5, 6) != 21) {
+            throw new Error("Expected 21");
+        }
     }
-  }
 }
diff --git a/test/719-varhandle-concurrency/src/Main.java b/test/719-varhandle-concurrency/src/Main.java
index 577cdbf07e..47f523f446 100644
--- a/test/719-varhandle-concurrency/src/Main.java
+++ b/test/719-varhandle-concurrency/src/Main.java
@@ -33,197 +33,196 @@ import java.util.function.Consumer;
  * were not run at all (skipped by all threads).
  */
 public class Main {
-  private static final VarHandle QA;
-  static {
-      QA = MethodHandles.arrayElementVarHandle(TestTask[].class);
-  }
-
-  private static final int TASK_COUNT = 10000;
-  private static final int THREAD_COUNT = 20;
-  /* Each test may need several retries before a concurrent failure is seen. In the past, for a
-   * known bug, between 5 and 10 retries were sufficient. Use RETRIES to configure how many
-   * iterations to retry for each test scenario. However, to avoid the test running for too long,
-   * for example with gcstress, set a cap duration in MAX_RETRIES_DURATION. With this at least one
-   * iteration would run, but there could be fewer retries if each of them takes too long. */
-  private static final int RETRIES = 50;
-  // b/235431387: timeout reduced from 1 minute
-  private static final Duration MAX_RETRIES_DURATION = Duration.ofSeconds(15);
-
-  public static void main(String[] args) throws Throwable {
-    testConcurrentProcessing(new CompareAndExchangeRunnerFactory(), "compareAndExchange");
-    testConcurrentProcessing(new CompareAndSetRunnerFactory(), "compareAndSet");
-    testConcurrentProcessing(new WeakCompareAndSetRunnerFactory(), "weakCompareAndSet");
-  }
-
-  private static void testConcurrentProcessing(RunnerFactory factory,
-          String testName) throws Throwable {
-    final Duration startTs = Duration.ofNanos(System.nanoTime());
-    final Duration endTs = startTs.plus(MAX_RETRIES_DURATION);
-    for (int i = 0; i < RETRIES; ++i) {
-      concurrentProcessingTestIteration(factory, i, testName);
-      Duration now = Duration.ofNanos(System.nanoTime());
-      if (0 < now.compareTo(endTs)) {
-          break;
-      }
+    private static final VarHandle QA;
+    static {
+        QA = MethodHandles.arrayElementVarHandle(TestTask[].class);
     }
-  }
-
-  private static void concurrentProcessingTestIteration(RunnerFactory factory,
-          int iteration, String testName) throws Throwable {
-      final TestTask[] tasks = new TestTask[TASK_COUNT];
-      final AtomicInteger result = new AtomicInteger();
-
-      for (int i = 0; i < TASK_COUNT; ++i) {
-          tasks[i] = new TestTask(Integer.valueOf(i+1), result::addAndGet);
-      }
-
-      Thread[] threads = new Thread[THREAD_COUNT];
-      for (int i = 0; i < THREAD_COUNT; ++i) {
-          threads[i] = factory.createRunner(tasks);
-      }
-
-      for (int i = 0; i < THREAD_COUNT; ++i) {
-          threads[i].start();
-      }
-
-      for (int i = 0; i < THREAD_COUNT; ++i) {
-          threads[i].join();
-      }
-
-      check(result.get(), TASK_COUNT * (TASK_COUNT + 1) / 2,
-              testName + " test result not as expected", iteration);
-  }
-
-  /**
-   * Processes the task queue until there are no tasks left.
-   *
-   * The actual task-grabbing mechanism is implemented in subclasses through grabTask(). This allows
-   * testing various mechanisms, like compareAndSet() and compareAndExchange().
-   */
-  private static abstract class TaskRunner extends Thread {
-
-      protected final TestTask[] tasks;
-
-      TaskRunner(TestTask[] tasks) {
-          this.tasks = tasks;
-      }
-
-      @Override
-      public void run() {
-          int i = 0;
-          while (i < TASK_COUNT) {
-              TestTask t = (TestTask) QA.get(tasks, i);
-              if (t == null) {
-                  ++i;
-                  continue;
-              }
-              if (!grabTask(t, i)) {
-                  continue;
-              }
-              ++i;
-              VarHandle.releaseFence();
-              t.exec();
-          }
-      }
-
-      /**
-       * Grabs the next task from the queue in an atomic way.
-       * 
-       * Once a task is retrieved successfully, the queue should no longer hold a reference to it.
-       * This would be done, for example, by swapping the task with a null value.
-       *
-       * @param t The task to get from the queue
-       * @param i The index where the task is found
-       *
-       * @return {@code true} if the task has been retrieved and is not available to any other
-       * threads. Otherwise {@code false}. If {@code false} is returned, then either the task was no
-       * longer present on the queue due to another thread grabbing it, or, in case of spurious
-       * failure, the task is still available and no other thread managed to grab it.
-       */
-      protected abstract boolean grabTask(TestTask t, int i);
-  }
-
-  private static class TaskRunnerWithCompareAndExchange extends TaskRunner {
-
-      TaskRunnerWithCompareAndExchange(TestTask[] tasks) {
-          super(tasks);
-      }
-
-      @Override
-      protected boolean grabTask(TestTask t, int i) {
-          return (t == QA.compareAndExchange(tasks, i, t, null));
-      }
-  }
-
-  private static class TaskRunnerWithCompareAndSet extends TaskRunner {
-
-      TaskRunnerWithCompareAndSet(TestTask[] tasks) {
-          super(tasks);
-      }
-
-      @Override
-      protected boolean grabTask(TestTask t, int i) {
-          return QA.compareAndSet(tasks, i, t, null);
-      }
-  }
-
-  private static class TaskRunnerWithWeakCompareAndSet extends TaskRunner {
-
-      TaskRunnerWithWeakCompareAndSet(TestTask[] tasks) {
-          super(tasks);
-      }
-
-      @Override
-      protected boolean grabTask(TestTask t, int i) {
-          return QA.weakCompareAndSet(tasks, i, t, null);
-      }
-  }
-
-
-  private interface RunnerFactory {
-      Thread createRunner(TestTask[] tasks);
-  }
-
-  private static class CompareAndExchangeRunnerFactory implements RunnerFactory {
-      @Override
-      public Thread createRunner(TestTask[] tasks) {
-          return new TaskRunnerWithCompareAndExchange(tasks);
-      }
-  }
-
-  private static class CompareAndSetRunnerFactory implements RunnerFactory {
-      @Override
-      public Thread createRunner(TestTask[] tasks) {
-          return new TaskRunnerWithCompareAndSet(tasks);
-      }
-  }
-
-  private static class WeakCompareAndSetRunnerFactory implements RunnerFactory {
-      @Override
-      public Thread createRunner(TestTask[] tasks) {
-          return new TaskRunnerWithWeakCompareAndSet(tasks);
-      }
-  }
-
-  private static class TestTask {
-      private final Integer ord;
-      private final Consumer<Integer> action;
-
-      TestTask(Integer ord, Consumer<Integer> action) {
-          this.ord = ord;
-          this.action = action;
-      }
-
-      public void exec() {
-          action.accept(ord);
-      }
-  }
-
-  private static void check(int actual, int expected, String msg, int iteration) {
-    if (actual != expected) {
-      System.err.println(String.format("[iteration %d] %s : %d != %d",
-                  iteration, msg, actual, expected));
-      System.exit(1);
+
+    private static final int TASK_COUNT = 10000;
+    private static final int THREAD_COUNT = 20;
+    /* Each test may need several retries before a concurrent failure is seen. In the past, for a
+     * known bug, between 5 and 10 retries were sufficient. Use RETRIES to configure how many
+     * iterations to retry for each test scenario. However, to avoid the test running for too long,
+     * for example with gcstress, set a cap duration in MAX_RETRIES_DURATION. With this at least one
+     * iteration would run, but there could be fewer retries if each of them takes too long. */
+    private static final int RETRIES = 50;
+    // b/235431387: timeout reduced from 1 minute
+    private static final Duration MAX_RETRIES_DURATION = Duration.ofSeconds(15);
+
+    public static void main(String[] args) throws Throwable {
+        testConcurrentProcessing(new CompareAndExchangeRunnerFactory(), "compareAndExchange");
+        testConcurrentProcessing(new CompareAndSetRunnerFactory(), "compareAndSet");
+        testConcurrentProcessing(new WeakCompareAndSetRunnerFactory(), "weakCompareAndSet");
+    }
+
+    private static void testConcurrentProcessing(RunnerFactory factory, String testName)
+            throws Throwable {
+        final Duration startTs = Duration.ofNanos(System.nanoTime());
+        final Duration endTs = startTs.plus(MAX_RETRIES_DURATION);
+        for (int i = 0; i < RETRIES; ++i) {
+            concurrentProcessingTestIteration(factory, i, testName);
+            Duration now = Duration.ofNanos(System.nanoTime());
+            if (0 < now.compareTo(endTs)) {
+                break;
+            }
+        }
+    }
+
+    private static void concurrentProcessingTestIteration(
+            RunnerFactory factory, int iteration, String testName) throws Throwable {
+        final TestTask[] tasks = new TestTask[TASK_COUNT];
+        final AtomicInteger result = new AtomicInteger();
+
+        for (int i = 0; i < TASK_COUNT; ++i) {
+            tasks[i] = new TestTask(Integer.valueOf(i + 1), result::addAndGet);
+        }
+
+        Thread[] threads = new Thread[THREAD_COUNT];
+        for (int i = 0; i < THREAD_COUNT; ++i) {
+            threads[i] = factory.createRunner(tasks);
+        }
+
+        for (int i = 0; i < THREAD_COUNT; ++i) {
+            threads[i].start();
+        }
+
+        for (int i = 0; i < THREAD_COUNT; ++i) {
+            threads[i].join();
+        }
+
+        check(result.get(),
+              TASK_COUNT * (TASK_COUNT + 1) / 2,
+              testName + " test result not as expected",
+              iteration);
+    }
+
+    /**
+     * Processes the task queue until there are no tasks left.
+     *
+     * The actual task-grabbing mechanism is implemented in subclasses through grabTask().
+     * This allows testing various mechanisms, like compareAndSet() and compareAndExchange().
+     */
+    private static abstract class TaskRunner extends Thread {
+
+        protected final TestTask[] tasks;
+
+        TaskRunner(TestTask[] tasks) {
+            this.tasks = tasks;
+        }
+
+        @Override
+        public void run() {
+            int i = 0;
+            while (i < TASK_COUNT) {
+                TestTask t = (TestTask) QA.get(tasks, i);
+                if (t == null) {
+                    ++i;
+                    continue;
+                }
+                if (!grabTask(t, i)) {
+                    continue;
+                }
+                ++i;
+                VarHandle.releaseFence();
+                t.exec();
+            }
+        }
+
+        /**
+         * Grabs the next task from the queue in an atomic way.
+         *
+         * Once a task is retrieved successfully, the queue should no longer hold a reference to it.
+         * This would be done, for example, by swapping the task with a null value.
+         *
+         * @param t The task to get from the queue
+         * @param i The index where the task is found
+         *
+         * @return {@code true} if the task has been retrieved and is not available to any other
+         * threads. Otherwise {@code false}. If {@code false} is returned, then either the task was
+         * no longer present on the queue due to another thread grabbing it, or, in case of spurious
+         * failure, the task is still available and no other thread managed to grab it.
+         */
+        protected abstract boolean grabTask(TestTask t, int i);
+    }
+
+    private static class TaskRunnerWithCompareAndExchange extends TaskRunner {
+        TaskRunnerWithCompareAndExchange(TestTask[] tasks) {
+            super(tasks);
+        }
+
+        @Override
+        protected boolean grabTask(TestTask t, int i) {
+            return (t == QA.compareAndExchange(tasks, i, t, null));
+        }
+    }
+
+    private static class TaskRunnerWithCompareAndSet extends TaskRunner {
+        TaskRunnerWithCompareAndSet(TestTask[] tasks) {
+            super(tasks);
+        }
+
+        @Override
+        protected boolean grabTask(TestTask t, int i) {
+            return QA.compareAndSet(tasks, i, t, null);
+        }
+    }
+
+    private static class TaskRunnerWithWeakCompareAndSet extends TaskRunner {
+        TaskRunnerWithWeakCompareAndSet(TestTask[] tasks) {
+            super(tasks);
+        }
+
+        @Override
+        protected boolean grabTask(TestTask t, int i) {
+            return QA.weakCompareAndSet(tasks, i, t, null);
+        }
+    }
+
+
+    private interface RunnerFactory {
+        Thread createRunner(TestTask[] tasks);
+    }
+
+    private static class CompareAndExchangeRunnerFactory implements RunnerFactory {
+        @Override
+        public Thread createRunner(TestTask[] tasks) {
+            return new TaskRunnerWithCompareAndExchange(tasks);
+        }
+    }
+
+    private static class CompareAndSetRunnerFactory implements RunnerFactory {
+        @Override
+        public Thread createRunner(TestTask[] tasks) {
+            return new TaskRunnerWithCompareAndSet(tasks);
+        }
+    }
+
+    private static class WeakCompareAndSetRunnerFactory implements RunnerFactory {
+        @Override
+        public Thread createRunner(TestTask[] tasks) {
+            return new TaskRunnerWithWeakCompareAndSet(tasks);
+        }
+    }
+
+    private static class TestTask {
+        private final Integer ord;
+        private final Consumer<Integer> action;
+
+        TestTask(Integer ord, Consumer<Integer> action) {
+            this.ord = ord;
+            this.action = action;
+        }
+
+        public void exec() {
+            action.accept(ord);
+        }
+    }
+
+    private static void check(int actual, int expected, String msg, int iteration) {
+        if (actual != expected) {
+            System.err.println(String.format(
+                    "[iteration %d] %s : %d != %d", iteration, msg, actual, expected));
+            System.exit(1);
+        }
     }
-  }
 }
diff --git a/test/815-invokeinterface-default/src/Main.java b/test/815-invokeinterface-default/src/Main.java
index db3612b646..97321c8022 100644
--- a/test/815-invokeinterface-default/src/Main.java
+++ b/test/815-invokeinterface-default/src/Main.java
@@ -18,174 +18,174 @@ import java.lang.reflect.Method;
 
 // An interface with enough methods to trigger a conflict.
 interface Itf {
-  public void method0a();
-  public void method0b();
-  public void method0c();
-  public void method0d();
-  public void method0e();
-  public void method0f();
-  public void method0g();
-  public void method0h();
-  public void method0i();
-  public void method0j();
-  public void method0k();
-  public void method0l();
-  public void method0m();
-  public void method0n();
-  public void method0o();
-  public void method0p();
-  public void method0q();
-  public void method0r();
-  public void method0s();
-  public void method0t();
-  public void method0u();
-  public void method0v();
-  public void method0w();
-  public void method0x();
-  public void method0y();
-  public void method0z();
-  public void method1a();
-  public void method1b();
-  public void method1c();
-  public void method1d();
-  public void method1e();
-  public void method1f();
-  public void method1g();
-  public void method1h();
-  public void method1i();
-  public void method1j();
-  public void method1k();
-  public void method1l();
-  public void method1m();
-  public void method1n();
-  public void method1o();
-  public void method1p();
-  public void method1q();
-  public void method1r();
-  public void method1s();
-  public void method1t();
-  public void method1u();
-  public void method1v();
-  public void method1w();
-  public void method1x();
-  public void method1y();
-  public void method1z();
-  public void method2a();
-  public void method2b();
-  public void method2c();
-  public void method2d();
-  public void method2e();
-  public void method2f();
-  public void method2g();
-  public void method2h();
-  public void method2i();
-  public void method2j();
-  public void method2k();
-  public void method2l();
-  public void method2m();
-  public void method2n();
-  public void method2o();
-  public void method2p();
-  public void method2q();
-  public void method2r();
-  public void method2s();
-  public void method2t();
-  public void method2u();
-  public void method2v();
-  public void method2w();
-  public void method2x();
-  public void method2y();
-  public void method2z();
+    public void method0a();
+    public void method0b();
+    public void method0c();
+    public void method0d();
+    public void method0e();
+    public void method0f();
+    public void method0g();
+    public void method0h();
+    public void method0i();
+    public void method0j();
+    public void method0k();
+    public void method0l();
+    public void method0m();
+    public void method0n();
+    public void method0o();
+    public void method0p();
+    public void method0q();
+    public void method0r();
+    public void method0s();
+    public void method0t();
+    public void method0u();
+    public void method0v();
+    public void method0w();
+    public void method0x();
+    public void method0y();
+    public void method0z();
+    public void method1a();
+    public void method1b();
+    public void method1c();
+    public void method1d();
+    public void method1e();
+    public void method1f();
+    public void method1g();
+    public void method1h();
+    public void method1i();
+    public void method1j();
+    public void method1k();
+    public void method1l();
+    public void method1m();
+    public void method1n();
+    public void method1o();
+    public void method1p();
+    public void method1q();
+    public void method1r();
+    public void method1s();
+    public void method1t();
+    public void method1u();
+    public void method1v();
+    public void method1w();
+    public void method1x();
+    public void method1y();
+    public void method1z();
+    public void method2a();
+    public void method2b();
+    public void method2c();
+    public void method2d();
+    public void method2e();
+    public void method2f();
+    public void method2g();
+    public void method2h();
+    public void method2i();
+    public void method2j();
+    public void method2k();
+    public void method2l();
+    public void method2m();
+    public void method2n();
+    public void method2o();
+    public void method2p();
+    public void method2q();
+    public void method2r();
+    public void method2s();
+    public void method2t();
+    public void method2u();
+    public void method2v();
+    public void method2w();
+    public void method2x();
+    public void method2y();
+    public void method2z();
 
-  public default void $noinline$defaultRecursiveMethod(boolean callRecursive) {
-    if (callRecursive) {
-      $noinline$defaultRecursiveMethod(false);
+    public default void $noinline$defaultRecursiveMethod(boolean callRecursive) {
+        if (callRecursive) {
+            $noinline$defaultRecursiveMethod(false);
+        }
     }
-  }
 }
 
 public class Main implements Itf {
-  public static void main(String[] args) throws Exception {
-    Main main = new Main();
-    main.$noinline$defaultRecursiveMethod(true);
-  }
+    public static void main(String[] args) throws Exception {
+        Main main = new Main();
+        main.$noinline$defaultRecursiveMethod(true);
+    }
 
-  public void method0a() {}
-  public void method0b() {}
-  public void method0c() {}
-  public void method0d() {}
-  public void method0e() {}
-  public void method0f() {}
-  public void method0g() {}
-  public void method0h() {}
-  public void method0i() {}
-  public void method0j() {}
-  public void method0k() {}
-  public void method0l() {}
-  public void method0m() {}
-  public void method0n() {}
-  public void method0o() {}
-  public void method0p() {}
-  public void method0q() {}
-  public void method0r() {}
-  public void method0s() {}
-  public void method0t() {}
-  public void method0u() {}
-  public void method0v() {}
-  public void method0w() {}
-  public void method0x() {}
-  public void method0y() {}
-  public void method0z() {}
-  public void method1a() {}
-  public void method1b() {}
-  public void method1c() {}
-  public void method1d() {}
-  public void method1e() {}
-  public void method1f() {}
-  public void method1g() {}
-  public void method1h() {}
-  public void method1i() {}
-  public void method1j() {}
-  public void method1k() {}
-  public void method1l() {}
-  public void method1m() {}
-  public void method1n() {}
-  public void method1o() {}
-  public void method1p() {}
-  public void method1q() {}
-  public void method1r() {}
-  public void method1s() {}
-  public void method1t() {}
-  public void method1u() {}
-  public void method1v() {}
-  public void method1w() {}
-  public void method1x() {}
-  public void method1y() {}
-  public void method1z() {}
-  public void method2a() {}
-  public void method2b() {}
-  public void method2c() {}
-  public void method2d() {}
-  public void method2e() {}
-  public void method2f() {}
-  public void method2g() {}
-  public void method2h() {}
-  public void method2i() {}
-  public void method2j() {}
-  public void method2k() {}
-  public void method2l() {}
-  public void method2m() {}
-  public void method2n() {}
-  public void method2o() {}
-  public void method2p() {}
-  public void method2q() {}
-  public void method2r() {}
-  public void method2s() {}
-  public void method2t() {}
-  public void method2u() {}
-  public void method2v() {}
-  public void method2w() {}
-  public void method2x() {}
-  public void method2y() {}
-  public void method2z() {}
+    public void method0a() {}
+    public void method0b() {}
+    public void method0c() {}
+    public void method0d() {}
+    public void method0e() {}
+    public void method0f() {}
+    public void method0g() {}
+    public void method0h() {}
+    public void method0i() {}
+    public void method0j() {}
+    public void method0k() {}
+    public void method0l() {}
+    public void method0m() {}
+    public void method0n() {}
+    public void method0o() {}
+    public void method0p() {}
+    public void method0q() {}
+    public void method0r() {}
+    public void method0s() {}
+    public void method0t() {}
+    public void method0u() {}
+    public void method0v() {}
+    public void method0w() {}
+    public void method0x() {}
+    public void method0y() {}
+    public void method0z() {}
+    public void method1a() {}
+    public void method1b() {}
+    public void method1c() {}
+    public void method1d() {}
+    public void method1e() {}
+    public void method1f() {}
+    public void method1g() {}
+    public void method1h() {}
+    public void method1i() {}
+    public void method1j() {}
+    public void method1k() {}
+    public void method1l() {}
+    public void method1m() {}
+    public void method1n() {}
+    public void method1o() {}
+    public void method1p() {}
+    public void method1q() {}
+    public void method1r() {}
+    public void method1s() {}
+    public void method1t() {}
+    public void method1u() {}
+    public void method1v() {}
+    public void method1w() {}
+    public void method1x() {}
+    public void method1y() {}
+    public void method1z() {}
+    public void method2a() {}
+    public void method2b() {}
+    public void method2c() {}
+    public void method2d() {}
+    public void method2e() {}
+    public void method2f() {}
+    public void method2g() {}
+    public void method2h() {}
+    public void method2i() {}
+    public void method2j() {}
+    public void method2k() {}
+    public void method2l() {}
+    public void method2m() {}
+    public void method2n() {}
+    public void method2o() {}
+    public void method2p() {}
+    public void method2q() {}
+    public void method2r() {}
+    public void method2s() {}
+    public void method2t() {}
+    public void method2u() {}
+    public void method2v() {}
+    public void method2w() {}
+    public void method2x() {}
+    public void method2y() {}
+    public void method2z() {}
 }
diff --git a/test/818-clinit-nterp/src/Main.java b/test/818-clinit-nterp/src/Main.java
index 5342cecf2f..5ebd384797 100644
--- a/test/818-clinit-nterp/src/Main.java
+++ b/test/818-clinit-nterp/src/Main.java
@@ -15,20 +15,19 @@
  */
 
 public class Main {
-  public static void main(String[] args) {
-    Clinit.run();
-    if (!clinitDidRun) {
-      throw new Error("Expected Clinit.<clinit> to have run");
+    public static void main(String[] args) {
+        Clinit.run();
+        if (!clinitDidRun) {
+            throw new Error("Expected Clinit.<clinit> to have run");
+        }
     }
-  }
-  static boolean clinitDidRun = false;
+    static boolean clinitDidRun = false;
 }
 
 class Clinit {
-  public static void run() {
-  }
+    public static void run() {}
 
-  static {
-    Main.clinitDidRun = true;
-  }
+    static {
+        Main.clinitDidRun = true;
+    }
 }
diff --git a/test/915-obsolete-2/src/Main.java b/test/915-obsolete-2/src/Main.java
index be51234c87..58c4ab9da9 100644
--- a/test/915-obsolete-2/src/Main.java
+++ b/test/915-obsolete-2/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test915.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test915.run();
+    }
 }
diff --git a/test/915-obsolete-2/src/art/Test915.java b/test/915-obsolete-2/src/art/Test915.java
index 63c7f344dd..2cb3c8fbd7 100644
--- a/test/915-obsolete-2/src/art/Test915.java
+++ b/test/915-obsolete-2/src/art/Test915.java
@@ -19,105 +19,104 @@ package art;
 import java.util.Base64;
 
 public class Test915 {
+    static class Transform {
+        private void Start() {
+            System.out.println("hello - private");
+        }
 
-  static class Transform {
-    private void Start() {
-      System.out.println("hello - private");
-    }
-
-    private void Finish() {
-      System.out.println("goodbye - private");
-    }
+        private void Finish() {
+            System.out.println("goodbye - private");
+        }
 
-    public void sayHi(Runnable r) {
-      System.out.println("Pre Start private method call");
-      Start();
-      System.out.println("Post Start private method call");
-      r.run();
-      System.out.println("Pre Finish private method call");
-      Finish();
-      System.out.println("Post Finish private method call");
+        public void sayHi(Runnable r) {
+            System.out.println("Pre Start private method call");
+            Start();
+            System.out.println("Post Start private method call");
+            r.run();
+            System.out.println("Pre Finish private method call");
+            Finish();
+            System.out.println("Post Finish private method call");
+        }
     }
-  }
 
-  // static class Transform {
-  //   private void Start() {
-  //     System.out.println("Hello - private - Transformed");
-  //   }
-  //
-  //   private void Finish() {
-  //     System.out.println("Goodbye - private - Transformed");
-  //   }
-  //
-  //   public void sayHi(Runnable r) {
-  //     System.out.println("Pre Start private method call - Transformed");
-  //     Start();
-  //     System.out.println("Post Start private method call - Transformed");
-  //     r.run();
-  //     System.out.println("Pre Finish private method call - Transformed");
-  //     Finish();
-  //     System.out.println("Post Finish private method call - Transformed");
-  //   }
-  // }
-  private static final byte[] CLASS_BYTES = Base64.getDecoder().decode(
-    "yv66vgAAADQANgoADgAZCQAaABsIABwKAB0AHggAHwgAIAoADQAhCAAiCwAjACQIACUKAA0AJggA" +
-    "JwcAKQcALAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBAAVTdGFydAEA" +
-    "BkZpbmlzaAEABXNheUhpAQAXKExqYXZhL2xhbmcvUnVubmFibGU7KVYBAApTb3VyY2VGaWxlAQAM" +
-    "VGVzdDkxNS5qYXZhDAAPABAHAC0MAC4ALwEAHUhlbGxvIC0gcHJpdmF0ZSAtIFRyYW5zZm9ybWVk" +
-    "BwAwDAAxADIBAB9Hb29kYnllIC0gcHJpdmF0ZSAtIFRyYW5zZm9ybWVkAQArUHJlIFN0YXJ0IHBy" +
-    "aXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAwAEwAQAQAsUG9zdCBTdGFydCBwcml2YXRl" +
-    "IG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQHADMMADQAEAEALFByZSBGaW5pc2ggcHJpdmF0ZSBt" +
-    "ZXRob2QgY2FsbCAtIFRyYW5zZm9ybWVkDAAUABABAC1Qb3N0IEZpbmlzaCBwcml2YXRlIG1ldGhv" +
-    "ZCBjYWxsIC0gVHJhbnNmb3JtZWQHADUBABVhcnQvVGVzdDkxNSRUcmFuc2Zvcm0BAAlUcmFuc2Zv" +
-    "cm0BAAxJbm5lckNsYXNzZXMBABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEA" +
-    "A291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmlu" +
-    "dGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQASamF2YS9sYW5nL1J1bm5hYmxlAQADcnVuAQAL" +
-    "YXJ0L1Rlc3Q5MTUAIAANAA4AAAAAAAQAAAAPABAAAQARAAAAHQABAAEAAAAFKrcAAbEAAAABABIA" +
-    "AAAGAAEAAAAFAAIAEwAQAAEAEQAAACUAAgABAAAACbIAAhIDtgAEsQAAAAEAEgAAAAoAAgAAAAcA" +
-    "CAAIAAIAFAAQAAEAEQAAACUAAgABAAAACbIAAhIFtgAEsQAAAAEAEgAAAAoAAgAAAAoACAALAAEA" +
-    "FQAWAAEAEQAAAGMAAgACAAAAL7IAAhIGtgAEKrcAB7IAAhIItgAEK7kACQEAsgACEgq2AAQqtwAL" +
-    "sgACEgy2AASxAAAAAQASAAAAIgAIAAAADQAIAA4ADAAPABQAEAAaABEAIgASACYAEwAuABQAAgAX" +
-    "AAAAAgAYACsAAAAKAAEADQAoACoACA==");
-  private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
-    "ZGV4CjAzNQAQ+GYcAAAAAAAAAAAAAAAAAAAAAAAAAADUBQAAcAAAAHhWNBIAAAAAAAAAABAFAAAd" +
-    "AAAAcAAAAAoAAADkAAAAAwAAAAwBAAABAAAAMAEAAAcAAAA4AQAAAQAAAHABAABEBAAAkAEAAJAB" +
-    "AACYAQAAoAEAAMEBAADgAQAA+QEAAAgCAAAsAgAATAIAAGMCAAB3AgAAjQIAAKECAAC1AgAA5AIA" +
-    "ABIDAABAAwAAbQMAAHQDAACCAwAAjQMAAJADAACUAwAAoQMAAKcDAACsAwAAtQMAALoDAADBAwAA" +
-    "BAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAAFAAAABQAAAAJAAAAAAAAABUAAAAJ" +
-    "AAAA0AMAABUAAAAJAAAAyAMAAAgABAAYAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAARAAAAAAABABsA" +
-    "AAAEAAIAGQAAAAUAAAAAAAAABgAAABoAAAAAAAAAAAAAAAUAAAAAAAAAEgAAAAAFAADMBAAAAAAA" +
-    "AAY8aW5pdD4ABkZpbmlzaAAfR29vZGJ5ZSAtIHByaXZhdGUgLSBUcmFuc2Zvcm1lZAAdSGVsbG8g" +
-    "LSBwcml2YXRlIC0gVHJhbnNmb3JtZWQAF0xhcnQvVGVzdDkxNSRUcmFuc2Zvcm07AA1MYXJ0L1Rl" +
-    "c3Q5MTU7ACJMZGFsdmlrL2Fubm90YXRpb24vRW5jbG9zaW5nQ2xhc3M7AB5MZGFsdmlrL2Fubm90" +
-    "YXRpb24vSW5uZXJDbGFzczsAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwASTGphdmEvbGFuZy9PYmpl" +
-    "Y3Q7ABRMamF2YS9sYW5nL1J1bm5hYmxlOwASTGphdmEvbGFuZy9TdHJpbmc7ABJMamF2YS9sYW5n" +
-    "L1N5c3RlbTsALVBvc3QgRmluaXNoIHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAAs" +
-    "UG9zdCBTdGFydCBwcml2YXRlIG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQALFByZSBGaW5pc2gg" +
-    "cHJpdmF0ZSBtZXRob2QgY2FsbCAtIFRyYW5zZm9ybWVkACtQcmUgU3RhcnQgcHJpdmF0ZSBtZXRo" +
-    "b2QgY2FsbCAtIFRyYW5zZm9ybWVkAAVTdGFydAAMVGVzdDkxNS5qYXZhAAlUcmFuc2Zvcm0AAVYA" +
-    "AlZMAAthY2Nlc3NGbGFncwAEbmFtZQADb3V0AAdwcmludGxuAANydW4ABXNheUhpAAV2YWx1ZQAB" +
-    "AAAABwAAAAEAAAAGAAAABQAHDgAKAAcOAQgPAAcABw4BCA8ADQEABw4BCA8BAw8BCA8BAw8BCA8B" +
-    "Aw8BCA8AAQABAAEAAADYAwAABAAAAHAQBQAAAA4AAwABAAIAAADdAwAACQAAAGIAAAAbAQIAAABu" +
-    "IAQAEAAOAAAAAwABAAIAAADlAwAACQAAAGIAAAAbAQMAAABuIAQAEAAOAAAABAACAAIAAADtAwAA" +
-    "KgAAAGIAAAAbARAAAABuIAQAEABwEAIAAgBiAAAAGwEOAAAAbiAEABAAchAGAAMAYgAAABsBDwAA" +
-    "AG4gBAAQAHAQAQACAGIAAAAbAQ0AAABuIAQAEAAOAAAAAwEAgIAEiAgBAqAIAQLECAMB6AgAAAIC" +
-    "ARwYAQIDAhYECBcXEwACAAAA5AQAAOoEAAD0BAAAAAAAAAAAAAAAAAAAEAAAAAAAAAABAAAAAAAA" +
-    "AAEAAAAdAAAAcAAAAAIAAAAKAAAA5AAAAAMAAAADAAAADAEAAAQAAAABAAAAMAEAAAUAAAAHAAAA" +
-    "OAEAAAYAAAABAAAAcAEAAAIgAAAdAAAAkAEAAAEQAAACAAAAyAMAAAMgAAAEAAAA2AMAAAEgAAAE" +
-    "AAAACAQAAAAgAAABAAAAzAQAAAQgAAACAAAA5AQAAAMQAAABAAAA9AQAAAYgAAABAAAAAAUAAAAQ" +
-    "AAABAAAAEAUAAA==");
+    // static class Transform {
+    //   private void Start() {
+    //     System.out.println("Hello - private - Transformed");
+    //   }
+    //
+    //   private void Finish() {
+    //     System.out.println("Goodbye - private - Transformed");
+    //   }
+    //
+    //   public void sayHi(Runnable r) {
+    //     System.out.println("Pre Start private method call - Transformed");
+    //     Start();
+    //     System.out.println("Post Start private method call - Transformed");
+    //     r.run();
+    //     System.out.println("Pre Finish private method call - Transformed");
+    //     Finish();
+    //     System.out.println("Post Finish private method call - Transformed");
+    //   }
+    // }
+    private static final byte[] CLASS_BYTES = Base64.getDecoder().decode(
+            "yv66vgAAADQANgoADgAZCQAaABsIABwKAB0AHggAHwgAIAoADQAhCAAiCwAjACQIACUKAA0AJggA" +
+            "JwcAKQcALAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBAAVTdGFydAEA" +
+            "BkZpbmlzaAEABXNheUhpAQAXKExqYXZhL2xhbmcvUnVubmFibGU7KVYBAApTb3VyY2VGaWxlAQAM" +
+            "VGVzdDkxNS5qYXZhDAAPABAHAC0MAC4ALwEAHUhlbGxvIC0gcHJpdmF0ZSAtIFRyYW5zZm9ybWVk" +
+            "BwAwDAAxADIBAB9Hb29kYnllIC0gcHJpdmF0ZSAtIFRyYW5zZm9ybWVkAQArUHJlIFN0YXJ0IHBy" +
+            "aXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAwAEwAQAQAsUG9zdCBTdGFydCBwcml2YXRl" +
+            "IG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQHADMMADQAEAEALFByZSBGaW5pc2ggcHJpdmF0ZSBt" +
+            "ZXRob2QgY2FsbCAtIFRyYW5zZm9ybWVkDAAUABABAC1Qb3N0IEZpbmlzaCBwcml2YXRlIG1ldGhv" +
+            "ZCBjYWxsIC0gVHJhbnNmb3JtZWQHADUBABVhcnQvVGVzdDkxNSRUcmFuc2Zvcm0BAAlUcmFuc2Zv" +
+            "cm0BAAxJbm5lckNsYXNzZXMBABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEA" +
+            "A291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmlu" +
+            "dGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQASamF2YS9sYW5nL1J1bm5hYmxlAQADcnVuAQAL" +
+            "YXJ0L1Rlc3Q5MTUAIAANAA4AAAAAAAQAAAAPABAAAQARAAAAHQABAAEAAAAFKrcAAbEAAAABABIA" +
+            "AAAGAAEAAAAFAAIAEwAQAAEAEQAAACUAAgABAAAACbIAAhIDtgAEsQAAAAEAEgAAAAoAAgAAAAcA" +
+            "CAAIAAIAFAAQAAEAEQAAACUAAgABAAAACbIAAhIFtgAEsQAAAAEAEgAAAAoAAgAAAAoACAALAAEA" +
+            "FQAWAAEAEQAAAGMAAgACAAAAL7IAAhIGtgAEKrcAB7IAAhIItgAEK7kACQEAsgACEgq2AAQqtwAL" +
+            "sgACEgy2AASxAAAAAQASAAAAIgAIAAAADQAIAA4ADAAPABQAEAAaABEAIgASACYAEwAuABQAAgAX" +
+            "AAAAAgAYACsAAAAKAAEADQAoACoACA==");
+    private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
+            "ZGV4CjAzNQAQ+GYcAAAAAAAAAAAAAAAAAAAAAAAAAADUBQAAcAAAAHhWNBIAAAAAAAAAABAFAAAd" +
+            "AAAAcAAAAAoAAADkAAAAAwAAAAwBAAABAAAAMAEAAAcAAAA4AQAAAQAAAHABAABEBAAAkAEAAJAB" +
+            "AACYAQAAoAEAAMEBAADgAQAA+QEAAAgCAAAsAgAATAIAAGMCAAB3AgAAjQIAAKECAAC1AgAA5AIA" +
+            "ABIDAABAAwAAbQMAAHQDAACCAwAAjQMAAJADAACUAwAAoQMAAKcDAACsAwAAtQMAALoDAADBAwAA" +
+            "BAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAAFAAAABQAAAAJAAAAAAAAABUAAAAJ" +
+            "AAAA0AMAABUAAAAJAAAAyAMAAAgABAAYAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAARAAAAAAABABsA" +
+            "AAAEAAIAGQAAAAUAAAAAAAAABgAAABoAAAAAAAAAAAAAAAUAAAAAAAAAEgAAAAAFAADMBAAAAAAA" +
+            "AAY8aW5pdD4ABkZpbmlzaAAfR29vZGJ5ZSAtIHByaXZhdGUgLSBUcmFuc2Zvcm1lZAAdSGVsbG8g" +
+            "LSBwcml2YXRlIC0gVHJhbnNmb3JtZWQAF0xhcnQvVGVzdDkxNSRUcmFuc2Zvcm07AA1MYXJ0L1Rl" +
+            "c3Q5MTU7ACJMZGFsdmlrL2Fubm90YXRpb24vRW5jbG9zaW5nQ2xhc3M7AB5MZGFsdmlrL2Fubm90" +
+            "YXRpb24vSW5uZXJDbGFzczsAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwASTGphdmEvbGFuZy9PYmpl" +
+            "Y3Q7ABRMamF2YS9sYW5nL1J1bm5hYmxlOwASTGphdmEvbGFuZy9TdHJpbmc7ABJMamF2YS9sYW5n" +
+            "L1N5c3RlbTsALVBvc3QgRmluaXNoIHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAAs" +
+            "UG9zdCBTdGFydCBwcml2YXRlIG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQALFByZSBGaW5pc2gg" +
+            "cHJpdmF0ZSBtZXRob2QgY2FsbCAtIFRyYW5zZm9ybWVkACtQcmUgU3RhcnQgcHJpdmF0ZSBtZXRo" +
+            "b2QgY2FsbCAtIFRyYW5zZm9ybWVkAAVTdGFydAAMVGVzdDkxNS5qYXZhAAlUcmFuc2Zvcm0AAVYA" +
+            "AlZMAAthY2Nlc3NGbGFncwAEbmFtZQADb3V0AAdwcmludGxuAANydW4ABXNheUhpAAV2YWx1ZQAB" +
+            "AAAABwAAAAEAAAAGAAAABQAHDgAKAAcOAQgPAAcABw4BCA8ADQEABw4BCA8BAw8BCA8BAw8BCA8B" +
+            "Aw8BCA8AAQABAAEAAADYAwAABAAAAHAQBQAAAA4AAwABAAIAAADdAwAACQAAAGIAAAAbAQIAAABu" +
+            "IAQAEAAOAAAAAwABAAIAAADlAwAACQAAAGIAAAAbAQMAAABuIAQAEAAOAAAABAACAAIAAADtAwAA" +
+            "KgAAAGIAAAAbARAAAABuIAQAEABwEAIAAgBiAAAAGwEOAAAAbiAEABAAchAGAAMAYgAAABsBDwAA" +
+            "AG4gBAAQAHAQAQACAGIAAAAbAQ0AAABuIAQAEAAOAAAAAwEAgIAEiAgBAqAIAQLECAMB6AgAAAIC" +
+            "ARwYAQIDAhYECBcXEwACAAAA5AQAAOoEAAD0BAAAAAAAAAAAAAAAAAAAEAAAAAAAAAABAAAAAAAA" +
+            "AAEAAAAdAAAAcAAAAAIAAAAKAAAA5AAAAAMAAAADAAAADAEAAAQAAAABAAAAMAEAAAUAAAAHAAAA" +
+            "OAEAAAYAAAABAAAAcAEAAAIgAAAdAAAAkAEAAAEQAAACAAAAyAMAAAMgAAAEAAAA2AMAAAEgAAAE" +
+            "AAAACAQAAAAgAAABAAAAzAQAAAQgAAACAAAA5AQAAAMQAAABAAAA9AQAAAYgAAABAAAAAAUAAAAQ" +
+            "AAABAAAAEAUAAA==");
 
-  public static void run() {
-    Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
-    doTest(new Transform());
-  }
+    public static void run() {
+        Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
+        doTest(new Transform());
+    }
 
-  public static void doTest(Transform t) {
-    t.sayHi(() -> { System.out.println("Not doing anything here"); });
-    t.sayHi(() -> {
-      System.out.println("transforming calling function");
-      Redefinition.doCommonClassRedefinition(Transform.class, CLASS_BYTES, DEX_BYTES);
-    });
-    t.sayHi(() -> { System.out.println("Not doing anything here"); });
-  }
+    public static void doTest(Transform t) {
+        t.sayHi(() -> { System.out.println("Not doing anything here"); });
+        t.sayHi(() -> {
+            System.out.println("transforming calling function");
+            Redefinition.doCommonClassRedefinition(Transform.class, CLASS_BYTES, DEX_BYTES);
+        });
+        t.sayHi(() -> { System.out.println("Not doing anything here"); });
+    }
 }
diff --git a/test/917-fields-transformation/src/Main.java b/test/917-fields-transformation/src/Main.java
index 289b89f2f6..e277debb9c 100644
--- a/test/917-fields-transformation/src/Main.java
+++ b/test/917-fields-transformation/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test917.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test917.run();
+    }
 }
diff --git a/test/917-fields-transformation/src/art/Test917.java b/test/917-fields-transformation/src/art/Test917.java
index 245e92e200..ba9a06b187 100644
--- a/test/917-fields-transformation/src/art/Test917.java
+++ b/test/917-fields-transformation/src/art/Test917.java
@@ -18,80 +18,78 @@ package art;
 
 import java.util.Base64;
 public class Test917 {
+    static class Transform {
+        public String take1;
+        public String take2;
 
-  static class Transform {
-    public String take1;
-    public String take2;
+        public Transform(String take1, String take2) {
+            this.take1 = take1;
+            this.take2 = take2;
+        }
 
-    public Transform(String take1, String take2) {
-      this.take1 = take1;
-      this.take2 = take2;
+        public String getResult() {
+            return take1;
+        }
     }
 
-    public String getResult() {
-      return take1;
-    }
-  }
-
 
-  // base64 encoded class/dex file for
-  // static class Transform {
-  //   public String take1;
-  //   public String take2;
-  //
-  //   public Transform(String a, String b) {
-  //     take1 = a;
-  //     take2 = b;
-  //   }
-  //
-  //   public String getResult() {
-  //     return take2;
-  //   }
-  // }
-  private static final byte[] CLASS_BYTES = Base64.getDecoder().decode(
-    "yv66vgAAADQAGwoABQARCQAEABIJAAQAEwcAFQcAGAEABXRha2UxAQASTGphdmEvbGFuZy9TdHJp" +
-    "bmc7AQAFdGFrZTIBAAY8aW5pdD4BACcoTGphdmEvbGFuZy9TdHJpbmc7TGphdmEvbGFuZy9TdHJp" +
-    "bmc7KVYBAARDb2RlAQAPTGluZU51bWJlclRhYmxlAQAJZ2V0UmVzdWx0AQAUKClMamF2YS9sYW5n" +
-    "L1N0cmluZzsBAApTb3VyY2VGaWxlAQAMVGVzdDkxNy5qYXZhDAAJABkMAAYABwwACAAHBwAaAQAV" +
-    "YXJ0L1Rlc3Q5MTckVHJhbnNmb3JtAQAJVHJhbnNmb3JtAQAMSW5uZXJDbGFzc2VzAQAQamF2YS9s" +
-    "YW5nL09iamVjdAEAAygpVgEAC2FydC9UZXN0OTE3ACAABAAFAAAAAgABAAYABwAAAAEACAAHAAAA" +
-    "AgABAAkACgABAAsAAAAzAAIAAwAAAA8qtwABKiu1AAIqLLUAA7EAAAABAAwAAAASAAQAAAAJAAQA" +
-    "CgAJAAsADgAMAAEADQAOAAEACwAAAB0AAQABAAAABSq0AAOwAAAAAQAMAAAABgABAAAADwACAA8A" +
-    "AAACABAAFwAAAAoAAQAEABQAFgAI");
-  private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
-    "ZGV4CjAzNQBdcPySAAAAAAAAAAAAAAAAAAAAAAAAAACQAwAAcAAAAHhWNBIAAAAAAAAAAMwCAAAS" +
-    "AAAAcAAAAAcAAAC4AAAAAwAAANQAAAACAAAA+AAAAAMAAAAIAQAAAQAAACABAABQAgAAQAEAAEAB" +
-    "AABIAQAASwEAAGQBAABzAQAAlwEAALcBAADLAQAA3wEAAO0BAAD4AQAA+wEAAAACAAANAgAAGAIA" +
-    "AB4CAAAlAgAALAIAAAIAAAADAAAABAAAAAUAAAAGAAAABwAAAAoAAAABAAAABQAAAAAAAAAKAAAA" +
-    "BgAAAAAAAAALAAAABgAAADQCAAAAAAUADwAAAAAABQAQAAAAAAACAAAAAAAAAAAADQAAAAQAAQAA" +
-    "AAAAAAAAAAAAAAAEAAAAAAAAAAgAAAC8AgAAjAIAAAAAAAAGPGluaXQ+AAFMABdMYXJ0L1Rlc3Q5" +
-    "MTckVHJhbnNmb3JtOwANTGFydC9UZXN0OTE3OwAiTGRhbHZpay9hbm5vdGF0aW9uL0VuY2xvc2lu" +
-    "Z0NsYXNzOwAeTGRhbHZpay9hbm5vdGF0aW9uL0lubmVyQ2xhc3M7ABJMamF2YS9sYW5nL09iamVj" +
-    "dDsAEkxqYXZhL2xhbmcvU3RyaW5nOwAMVGVzdDkxNy5qYXZhAAlUcmFuc2Zvcm0AAVYAA1ZMTAAL" +
-    "YWNjZXNzRmxhZ3MACWdldFJlc3VsdAAEbmFtZQAFdGFrZTEABXRha2UyAAV2YWx1ZQAAAgAAAAUA" +
-    "BQAJAgAABw4BAw8BAg8BAg8ADwAHDgAAAAADAAMAAQAAADwCAAAIAAAAcBACAAAAWwEAAFsCAQAO" +
-    "AAIAAQAAAAAATAIAAAMAAABUEAEAEQAAAAACAQEAAQEBAIGABNQEAQH0BAAAAgIBERgBAgMCDAQI" +
-    "DhcJAAIAAACgAgAApgIAALACAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAEAAAAAAAAAAQAAABIAAABw" +
-    "AAAAAgAAAAcAAAC4AAAAAwAAAAMAAADUAAAABAAAAAIAAAD4AAAABQAAAAMAAAAIAQAABgAAAAEA" +
-    "AAAgAQAAAiAAABIAAABAAQAAARAAAAEAAAA0AgAAAyAAAAIAAAA8AgAAASAAAAIAAABUAgAAACAA" +
-    "AAEAAACMAgAABCAAAAIAAACgAgAAAxAAAAEAAACwAgAABiAAAAEAAAC8AgAAABAAAAEAAADMAgAA");
+    // base64 encoded class/dex file for
+    // static class Transform {
+    //   public String take1;
+    //   public String take2;
+    //
+    //   public Transform(String a, String b) {
+    //     take1 = a;
+    //     take2 = b;
+    //   }
+    //
+    //   public String getResult() {
+    //     return take2;
+    //   }
+    // }
+    private static final byte[] CLASS_BYTES = Base64.getDecoder().decode(
+            "yv66vgAAADQAGwoABQARCQAEABIJAAQAEwcAFQcAGAEABXRha2UxAQASTGphdmEvbGFuZy9TdHJp" +
+            "bmc7AQAFdGFrZTIBAAY8aW5pdD4BACcoTGphdmEvbGFuZy9TdHJpbmc7TGphdmEvbGFuZy9TdHJp" +
+            "bmc7KVYBAARDb2RlAQAPTGluZU51bWJlclRhYmxlAQAJZ2V0UmVzdWx0AQAUKClMamF2YS9sYW5n" +
+            "L1N0cmluZzsBAApTb3VyY2VGaWxlAQAMVGVzdDkxNy5qYXZhDAAJABkMAAYABwwACAAHBwAaAQAV" +
+            "YXJ0L1Rlc3Q5MTckVHJhbnNmb3JtAQAJVHJhbnNmb3JtAQAMSW5uZXJDbGFzc2VzAQAQamF2YS9s" +
+            "YW5nL09iamVjdAEAAygpVgEAC2FydC9UZXN0OTE3ACAABAAFAAAAAgABAAYABwAAAAEACAAHAAAA" +
+            "AgABAAkACgABAAsAAAAzAAIAAwAAAA8qtwABKiu1AAIqLLUAA7EAAAABAAwAAAASAAQAAAAJAAQA" +
+            "CgAJAAsADgAMAAEADQAOAAEACwAAAB0AAQABAAAABSq0AAOwAAAAAQAMAAAABgABAAAADwACAA8A" +
+            "AAACABAAFwAAAAoAAQAEABQAFgAI");
+    private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
+            "ZGV4CjAzNQBdcPySAAAAAAAAAAAAAAAAAAAAAAAAAACQAwAAcAAAAHhWNBIAAAAAAAAAAMwCAAAS" +
+            "AAAAcAAAAAcAAAC4AAAAAwAAANQAAAACAAAA+AAAAAMAAAAIAQAAAQAAACABAABQAgAAQAEAAEAB" +
+            "AABIAQAASwEAAGQBAABzAQAAlwEAALcBAADLAQAA3wEAAO0BAAD4AQAA+wEAAAACAAANAgAAGAIA" +
+            "AB4CAAAlAgAALAIAAAIAAAADAAAABAAAAAUAAAAGAAAABwAAAAoAAAABAAAABQAAAAAAAAAKAAAA" +
+            "BgAAAAAAAAALAAAABgAAADQCAAAAAAUADwAAAAAABQAQAAAAAAACAAAAAAAAAAAADQAAAAQAAQAA" +
+            "AAAAAAAAAAAAAAAEAAAAAAAAAAgAAAC8AgAAjAIAAAAAAAAGPGluaXQ+AAFMABdMYXJ0L1Rlc3Q5" +
+            "MTckVHJhbnNmb3JtOwANTGFydC9UZXN0OTE3OwAiTGRhbHZpay9hbm5vdGF0aW9uL0VuY2xvc2lu" +
+            "Z0NsYXNzOwAeTGRhbHZpay9hbm5vdGF0aW9uL0lubmVyQ2xhc3M7ABJMamF2YS9sYW5nL09iamVj" +
+            "dDsAEkxqYXZhL2xhbmcvU3RyaW5nOwAMVGVzdDkxNy5qYXZhAAlUcmFuc2Zvcm0AAVYAA1ZMTAAL" +
+            "YWNjZXNzRmxhZ3MACWdldFJlc3VsdAAEbmFtZQAFdGFrZTEABXRha2UyAAV2YWx1ZQAAAgAAAAUA" +
+            "BQAJAgAABw4BAw8BAg8BAg8ADwAHDgAAAAADAAMAAQAAADwCAAAIAAAAcBACAAAAWwEAAFsCAQAO" +
+            "AAIAAQAAAAAATAIAAAMAAABUEAEAEQAAAAACAQEAAQEBAIGABNQEAQH0BAAAAgIBERgBAgMCDAQI" +
+            "DhcJAAIAAACgAgAApgIAALACAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAEAAAAAAAAAAQAAABIAAABw" +
+            "AAAAAgAAAAcAAAC4AAAAAwAAAAMAAADUAAAABAAAAAIAAAD4AAAABQAAAAMAAAAIAQAABgAAAAEA" +
+            "AAAgAQAAAiAAABIAAABAAQAAARAAAAEAAAA0AgAAAyAAAAIAAAA8AgAAASAAAAIAAABUAgAAACAA" +
+            "AAEAAACMAgAABCAAAAIAAACgAgAAAxAAAAEAAACwAgAABiAAAAEAAAC8AgAAABAAAAEAAADMAgAA");
 
-  public static void run() {
-    Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
-    doTest(new Transform("Hello", "Goodbye"),
-           new Transform("start", "end"));
-  }
+    public static void run() {
+        Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
+        doTest(new Transform("Hello", "Goodbye"), new Transform("start", "end"));
+    }
 
-  private static void printTransform(Transform t) {
-    System.out.println("Result is " + t.getResult());
-    System.out.println("take1 is " + t.take1);
-    System.out.println("take2 is " + t.take2);
-  }
-  public static void doTest(Transform t1, Transform t2) {
-    printTransform(t1);
-    printTransform(t2);
-    Redefinition.doCommonClassRedefinition(Transform.class, CLASS_BYTES, DEX_BYTES);
-    printTransform(t1);
-    printTransform(t2);
-  }
+    private static void printTransform(Transform t) {
+        System.out.println("Result is " + t.getResult());
+        System.out.println("take1 is " + t.take1);
+        System.out.println("take2 is " + t.take2);
+    }
+    public static void doTest(Transform t1, Transform t2) {
+        printTransform(t1);
+        printTransform(t2);
+        Redefinition.doCommonClassRedefinition(Transform.class, CLASS_BYTES, DEX_BYTES);
+        printTransform(t1);
+        printTransform(t2);
+    }
 }
diff --git a/test/918-fields/src/Main.java b/test/918-fields/src/Main.java
index e0ed65c763..e9f9bc9a72 100644
--- a/test/918-fields/src/Main.java
+++ b/test/918-fields/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test918.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test918.run();
+    }
 }
diff --git a/test/918-fields/src/art/Test918.java b/test/918-fields/src/art/Test918.java
index 5328b0bbdb..966c093215 100644
--- a/test/918-fields/src/art/Test918.java
+++ b/test/918-fields/src/art/Test918.java
@@ -21,58 +21,57 @@ import java.lang.reflect.Field;
 import java.util.Arrays;
 
 public class Test918 {
-  public static void run() throws Exception {
-    doTest();
-  }
+    public static void run() throws Exception {
+        doTest();
+    }
 
-  public static void doTest() throws Exception {
-    testField(Math.class, "PI");
-    testField(InterruptedIOException.class, "bytesTransferred");
-    testField(Foo.class, "this$0");
-    testField(Bar.class, "VAL");
-    testField(Generics.class, "generics");
-    testField(Generics.class, "privateValue");
-  }
+    public static void doTest() throws Exception {
+        testField(Math.class, "PI");
+        testField(InterruptedIOException.class, "bytesTransferred");
+        testField(Foo.class, "this$0");
+        testField(Bar.class, "VAL");
+        testField(Generics.class, "generics");
+        testField(Generics.class, "privateValue");
+    }
 
-  private static void testField(Class<?> base, String fieldName)
-      throws Exception {
-    Field f = base.getDeclaredField(fieldName);
-    String[] result = getFieldName(f);
-    System.out.println(Arrays.toString(result));
+    private static void testField(Class<?> base, String fieldName) throws Exception {
+        Field f = base.getDeclaredField(fieldName);
+        String[] result = getFieldName(f);
+        System.out.println(Arrays.toString(result));
 
-    Class<?> declClass = getFieldDeclaringClass(f);
-    if (base != declClass) {
-      throw new RuntimeException("Declaring class not equal: " + base + " vs " + declClass);
-    }
-    System.out.println(declClass);
+        Class<?> declClass = getFieldDeclaringClass(f);
+        if (base != declClass) {
+            throw new RuntimeException("Declaring class not equal: " + base + " vs " + declClass);
+        }
+        System.out.println(declClass);
 
-    int modifiers = getFieldModifiers(f);
-    if (modifiers != f.getModifiers()) {
-      throw new RuntimeException("Modifiers not equal: " + f.getModifiers() + " vs " + modifiers);
-    }
-    System.out.println(modifiers);
+        int modifiers = getFieldModifiers(f);
+        if (modifiers != f.getModifiers()) {
+            throw new RuntimeException(
+                    "Modifiers not equal: " + f.getModifiers() + " vs " + modifiers);
+        }
+        System.out.println(modifiers);
 
-    boolean synth = isFieldSynthetic(f);
-    if (synth != f.isSynthetic()) {
-      throw new RuntimeException("Synthetic not equal: " + f.isSynthetic() + " vs " + synth);
+        boolean synth = isFieldSynthetic(f);
+        if (synth != f.isSynthetic()) {
+            throw new RuntimeException("Synthetic not equal: " + f.isSynthetic() + " vs " + synth);
+        }
+        System.out.println(synth);
     }
-    System.out.println(synth);
-  }
 
-  private static native String[] getFieldName(Field f);
-  private static native Class<?> getFieldDeclaringClass(Field f);
-  private static native int getFieldModifiers(Field f);
-  private static native boolean isFieldSynthetic(Field f);
+    private static native String[] getFieldName(Field f);
+    private static native Class<?> getFieldDeclaringClass(Field f);
+    private static native int getFieldModifiers(Field f);
+    private static native boolean isFieldSynthetic(Field f);
 
-  private class Foo {
-  }
+    private class Foo {}
 
-  private static interface Bar {
-    public static int VAL = 1;
-  }
+    private static interface Bar {
+        public static int VAL = 1;
+    }
 
-  private static class Generics<T> {
-    T generics;
-    private int privateValue = 42;
-  }
+    private static class Generics<T> {
+        T generics;
+        private int privateValue = 42;
+    }
 }
diff --git a/test/919-obsolete-fields/src/Main.java b/test/919-obsolete-fields/src/Main.java
index 10eadb271e..bb08324862 100644
--- a/test/919-obsolete-fields/src/Main.java
+++ b/test/919-obsolete-fields/src/Main.java
@@ -15,7 +15,7 @@
  */
 
 public class Main {
-  public static void main(String[] args) throws Exception {
-    art.Test919.run();
-  }
+    public static void main(String[] args) throws Exception {
+        art.Test919.run();
+    }
 }
diff --git a/test/919-obsolete-fields/src/art/Test919.java b/test/919-obsolete-fields/src/art/Test919.java
index 11971ef2e8..0ae53058f3 100644
--- a/test/919-obsolete-fields/src/art/Test919.java
+++ b/test/919-obsolete-fields/src/art/Test919.java
@@ -20,154 +20,153 @@ import java.util.function.Consumer;
 import java.util.Base64;
 
 public class Test919 {
-
-  static class Transform {
-    private Consumer<String> reporter;
-    public Transform(Consumer<String> reporter) {
-      this.reporter = reporter;
-    }
-
-    private void Start() {
-      reporter.accept("hello - private");
-    }
-
-    private void Finish() {
-      reporter.accept("goodbye - private");
-    }
-
-    public void sayHi(Runnable r) {
-      reporter.accept("Pre Start private method call");
-      Start();
-      reporter.accept("Post Start private method call");
-      r.run();
-      reporter.accept("Pre Finish private method call");
-      Finish();
-      reporter.accept("Post Finish private method call");
+    static class Transform {
+        private Consumer<String> reporter;
+        public Transform(Consumer<String> reporter) {
+            this.reporter = reporter;
+        }
+
+        private void Start() {
+            reporter.accept("hello - private");
+        }
+
+        private void Finish() {
+            reporter.accept("goodbye - private");
+        }
+
+        public void sayHi(Runnable r) {
+            reporter.accept("Pre Start private method call");
+            Start();
+            reporter.accept("Post Start private method call");
+            r.run();
+            reporter.accept("Pre Finish private method call");
+            Finish();
+            reporter.accept("Post Finish private method call");
+        }
     }
-  }
-
 
-  // What follows is the base64 encoded representation of the following class:
-  //
-  // import java.util.function.Consumer;
-  //
-  // static class Transform {
-  //   private Consumer<String> reporter;
-  //   public Transform(Consumer<String> reporter) {
-  //     this.reporter = reporter;
-  //   }
-  //
-  //   private void Start() {
-  //     reporter.accept("Hello - private - Transformed");
-  //   }
-  //
-  //   private void Finish() {
-  //     reporter.accept("Goodbye - private - Transformed");
-  //   }
-  //
-  //   public void sayHi(Runnable r) {
-  //     reporter.accept("pre Start private method call - Transformed");
-  //     Start();
-  //     reporter.accept("post Start private method call - Transformed");
-  //     r.run();
-  //     reporter.accept("pre Finish private method call - Transformed");
-  //     Finish();
-  //     reporter.accept("post Finish private method call - Transformed");
-  //   }
-  // }
-  private static final byte[] CLASS_BYTES = Base64.getDecoder().decode(
-    "yv66vgAAADQAOAoADgAfCQANACAIACELACIAIwgAJAgAJQoADQAmCAAnCwAoACkIACoKAA0AKwgA" +
-    "LAcALgcAMQEACHJlcG9ydGVyAQAdTGphdmEvdXRpbC9mdW5jdGlvbi9Db25zdW1lcjsBAAlTaWdu" +
-    "YXR1cmUBADFMamF2YS91dGlsL2Z1bmN0aW9uL0NvbnN1bWVyPExqYXZhL2xhbmcvU3RyaW5nOz47" +
-    "AQAGPGluaXQ+AQAgKExqYXZhL3V0aWwvZnVuY3Rpb24vQ29uc3VtZXI7KVYBAARDb2RlAQAPTGlu" +
-    "ZU51bWJlclRhYmxlAQA0KExqYXZhL3V0aWwvZnVuY3Rpb24vQ29uc3VtZXI8TGphdmEvbGFuZy9T" +
-    "dHJpbmc7PjspVgEABVN0YXJ0AQADKClWAQAGRmluaXNoAQAFc2F5SGkBABcoTGphdmEvbGFuZy9S" +
-    "dW5uYWJsZTspVgEAClNvdXJjZUZpbGUBAAxUZXN0OTE5LmphdmEMABMAGQwADwAQAQAdSGVsbG8g" +
-    "LSBwcml2YXRlIC0gVHJhbnNmb3JtZWQHADIMADMANAEAH0dvb2RieWUgLSBwcml2YXRlIC0gVHJh" +
-    "bnNmb3JtZWQBACtwcmUgU3RhcnQgcHJpdmF0ZSBtZXRob2QgY2FsbCAtIFRyYW5zZm9ybWVkDAAY" +
-    "ABkBACxwb3N0IFN0YXJ0IHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAcANQwANgAZ" +
-    "AQAscHJlIEZpbmlzaCBwcml2YXRlIG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQMABoAGQEALXBv" +
-    "c3QgRmluaXNoIHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAcANwEAFWFydC9UZXN0" +
-    "OTE5JFRyYW5zZm9ybQEACVRyYW5zZm9ybQEADElubmVyQ2xhc3NlcwEAEGphdmEvbGFuZy9PYmpl" +
-    "Y3QBABtqYXZhL3V0aWwvZnVuY3Rpb24vQ29uc3VtZXIBAAZhY2NlcHQBABUoTGphdmEvbGFuZy9P" +
-    "YmplY3Q7KVYBABJqYXZhL2xhbmcvUnVubmFibGUBAANydW4BAAthcnQvVGVzdDkxOQAgAA0ADgAA" +
-    "AAEAAgAPABAAAQARAAAAAgASAAQAAQATABQAAgAVAAAAKgACAAIAAAAKKrcAASortQACsQAAAAEA" +
-    "FgAAAA4AAwAAAAgABAAJAAkACgARAAAAAgAXAAIAGAAZAAEAFQAAACgAAgABAAAADCq0AAISA7kA" +
-    "BAIAsQAAAAEAFgAAAAoAAgAAAA0ACwAOAAIAGgAZAAEAFQAAACgAAgABAAAADCq0AAISBbkABAIA" +
-    "sQAAAAEAFgAAAAoAAgAAABEACwASAAEAGwAcAAEAFQAAAG8AAgACAAAAOyq0AAISBrkABAIAKrcA" +
-    "Byq0AAISCLkABAIAK7kACQEAKrQAAhIKuQAEAgAqtwALKrQAAhIMuQAEAgCxAAAAAQAWAAAAIgAI" +
-    "AAAAFQALABYADwAXABoAGAAgABkAKwAaAC8AGwA6ABwAAgAdAAAAAgAeADAAAAAKAAEADQAtAC8A" +
-    "CA==");
-  private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
-    "ZGV4CjAzNQBeEZYBAAAAAAAAAAAAAAAAAAAAAAAAAACMBgAAcAAAAHhWNBIAAAAAAAAAAMgFAAAi" +
-    "AAAAcAAAAAkAAAD4AAAABAAAABwBAAABAAAATAEAAAcAAABUAQAAAQAAAIwBAADgBAAArAEAAKwB" +
-    "AACvAQAAsgEAALoBAAC+AQAAxAEAAMwBAADtAQAADAIAACUCAAA0AgAAWAIAAHgCAACXAgAAqwIA" +
-    "AMECAADVAgAA8wIAABIDAAAZAwAAJwMAADIDAAA1AwAAOQMAAEEDAABOAwAAVAMAAIMDAACxAwAA" +
-    "3wMAAAwEAAAWBAAAGwQAACIEAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAAEQAAABUAAAAV" +
-    "AAAACAAAAAAAAAAWAAAACAAAADQEAAAWAAAACAAAADwEAAAWAAAACAAAACwEAAAAAAcAHgAAAAAA" +
-    "AwACAAAAAAAAAAUAAAAAAAAAEgAAAAAAAgAgAAAABQAAAAIAAAAGAAAAHwAAAAcAAQAXAAAAAAAA" +
-    "AAAAAAAFAAAAAAAAABMAAACoBQAARAUAAAAAAAABKAABPAAGPGluaXQ+AAI+OwAEPjspVgAGRmlu" +
-    "aXNoAB9Hb29kYnllIC0gcHJpdmF0ZSAtIFRyYW5zZm9ybWVkAB1IZWxsbyAtIHByaXZhdGUgLSBU" +
-    "cmFuc2Zvcm1lZAAXTGFydC9UZXN0OTE5JFRyYW5zZm9ybTsADUxhcnQvVGVzdDkxOTsAIkxkYWx2" +
-    "aWsvYW5ub3RhdGlvbi9FbmNsb3NpbmdDbGFzczsAHkxkYWx2aWsvYW5ub3RhdGlvbi9Jbm5lckNs" +
-    "YXNzOwAdTGRhbHZpay9hbm5vdGF0aW9uL1NpZ25hdHVyZTsAEkxqYXZhL2xhbmcvT2JqZWN0OwAU" +
-    "TGphdmEvbGFuZy9SdW5uYWJsZTsAEkxqYXZhL2xhbmcvU3RyaW5nOwAcTGphdmEvdXRpbC9mdW5j" +
-    "dGlvbi9Db25zdW1lcgAdTGphdmEvdXRpbC9mdW5jdGlvbi9Db25zdW1lcjsABVN0YXJ0AAxUZXN0" +
-    "OTE5LmphdmEACVRyYW5zZm9ybQABVgACVkwABmFjY2VwdAALYWNjZXNzRmxhZ3MABG5hbWUALXBv" +
-    "c3QgRmluaXNoIHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAAscG9zdCBTdGFydCBw" +
-    "cml2YXRlIG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQALHByZSBGaW5pc2ggcHJpdmF0ZSBtZXRo" +
-    "b2QgY2FsbCAtIFRyYW5zZm9ybWVkACtwcmUgU3RhcnQgcHJpdmF0ZSBtZXRob2QgY2FsbCAtIFRy" +
-    "YW5zZm9ybWVkAAhyZXBvcnRlcgADcnVuAAVzYXlIaQAFdmFsdWUAAAAAAQAAAAcAAAABAAAABQAA" +
-    "AAEAAAAGAAAACAEABw4BAw8BAg8AEQAHDgEIDwANAAcOAQgPABUBAAcOAQgPAQMPAQgPAQMPAQgP" +
-    "AQMPAQgPAAACAAIAAQAAAEQEAAAGAAAAcBAEAAAAWwEAAA4AAwABAAIAAABQBAAACQAAAFQgAAAb" +
-    "AQYAAAByIAYAEAAOAAAAAwABAAIAAABYBAAACQAAAFQgAAAbAQcAAAByIAYAEAAOAAAABAACAAIA" +
-    "AABgBAAAKgAAAFQgAAAbAR0AAAByIAYAEABwEAIAAgBUIAAAGwEbAAAAciAGABAAchAFAAMAVCAA" +
-    "ABsBHAAAAHIgBgAQAHAQAQACAFQgAAAbARoAAAByIAYAEAAOAAABAwEAAgCBgAT8CAECmAkBArwJ" +
-    "AwHgCQICASEYAQIDAhgECBkXFAIEASEcBBcQFwEXDxcDAgQBIRwFFwAXEBcBFw8XBAAAAAIAAABc" +
-    "BQAAYgUAAAEAAABrBQAAAQAAAHkFAACMBQAAAQAAAAEAAAAAAAAAAAAAAJgFAAAAAAAAoAUAABAA" +
-    "AAAAAAAAAQAAAAAAAAABAAAAIgAAAHAAAAACAAAACQAAAPgAAAADAAAABAAAABwBAAAEAAAAAQAA" +
-    "AEwBAAAFAAAABwAAAFQBAAAGAAAAAQAAAIwBAAACIAAAIgAAAKwBAAABEAAAAwAAACwEAAADIAAA" +
-    "BAAAAEQEAAABIAAABAAAAHwEAAAAIAAAAQAAAEQFAAAEIAAABAAAAFwFAAADEAAAAwAAAIwFAAAG" +
-    "IAAAAQAAAKgFAAAAEAAAAQAAAMgFAAA=");
 
-  // A class that we can use to keep track of the output of this test.
-  private static class TestWatcher implements Consumer<String> {
-    private StringBuilder sb;
-    public TestWatcher() {
-      sb = new StringBuilder();
+    // What follows is the base64 encoded representation of the following class:
+    //
+    // import java.util.function.Consumer;
+    //
+    // static class Transform {
+    //   private Consumer<String> reporter;
+    //   public Transform(Consumer<String> reporter) {
+    //     this.reporter = reporter;
+    //   }
+    //
+    //   private void Start() {
+    //     reporter.accept("Hello - private - Transformed");
+    //   }
+    //
+    //   private void Finish() {
+    //     reporter.accept("Goodbye - private - Transformed");
+    //   }
+    //
+    //   public void sayHi(Runnable r) {
+    //     reporter.accept("pre Start private method call - Transformed");
+    //     Start();
+    //     reporter.accept("post Start private method call - Transformed");
+    //     r.run();
+    //     reporter.accept("pre Finish private method call - Transformed");
+    //     Finish();
+    //     reporter.accept("post Finish private method call - Transformed");
+    //   }
+    // }
+    private static final byte[] CLASS_BYTES = Base64.getDecoder().decode(
+            "yv66vgAAADQAOAoADgAfCQANACAIACELACIAIwgAJAgAJQoADQAmCAAnCwAoACkIACoKAA0AKwgA" +
+            "LAcALgcAMQEACHJlcG9ydGVyAQAdTGphdmEvdXRpbC9mdW5jdGlvbi9Db25zdW1lcjsBAAlTaWdu" +
+            "YXR1cmUBADFMamF2YS91dGlsL2Z1bmN0aW9uL0NvbnN1bWVyPExqYXZhL2xhbmcvU3RyaW5nOz47" +
+            "AQAGPGluaXQ+AQAgKExqYXZhL3V0aWwvZnVuY3Rpb24vQ29uc3VtZXI7KVYBAARDb2RlAQAPTGlu" +
+            "ZU51bWJlclRhYmxlAQA0KExqYXZhL3V0aWwvZnVuY3Rpb24vQ29uc3VtZXI8TGphdmEvbGFuZy9T" +
+            "dHJpbmc7PjspVgEABVN0YXJ0AQADKClWAQAGRmluaXNoAQAFc2F5SGkBABcoTGphdmEvbGFuZy9S" +
+            "dW5uYWJsZTspVgEAClNvdXJjZUZpbGUBAAxUZXN0OTE5LmphdmEMABMAGQwADwAQAQAdSGVsbG8g" +
+            "LSBwcml2YXRlIC0gVHJhbnNmb3JtZWQHADIMADMANAEAH0dvb2RieWUgLSBwcml2YXRlIC0gVHJh" +
+            "bnNmb3JtZWQBACtwcmUgU3RhcnQgcHJpdmF0ZSBtZXRob2QgY2FsbCAtIFRyYW5zZm9ybWVkDAAY" +
+            "ABkBACxwb3N0IFN0YXJ0IHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAcANQwANgAZ" +
+            "AQAscHJlIEZpbmlzaCBwcml2YXRlIG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQMABoAGQEALXBv" +
+            "c3QgRmluaXNoIHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAcANwEAFWFydC9UZXN0" +
+            "OTE5JFRyYW5zZm9ybQEACVRyYW5zZm9ybQEADElubmVyQ2xhc3NlcwEAEGphdmEvbGFuZy9PYmpl" +
+            "Y3QBABtqYXZhL3V0aWwvZnVuY3Rpb24vQ29uc3VtZXIBAAZhY2NlcHQBABUoTGphdmEvbGFuZy9P" +
+            "YmplY3Q7KVYBABJqYXZhL2xhbmcvUnVubmFibGUBAANydW4BAAthcnQvVGVzdDkxOQAgAA0ADgAA" +
+            "AAEAAgAPABAAAQARAAAAAgASAAQAAQATABQAAgAVAAAAKgACAAIAAAAKKrcAASortQACsQAAAAEA" +
+            "FgAAAA4AAwAAAAgABAAJAAkACgARAAAAAgAXAAIAGAAZAAEAFQAAACgAAgABAAAADCq0AAISA7kA" +
+            "BAIAsQAAAAEAFgAAAAoAAgAAAA0ACwAOAAIAGgAZAAEAFQAAACgAAgABAAAADCq0AAISBbkABAIA" +
+            "sQAAAAEAFgAAAAoAAgAAABEACwASAAEAGwAcAAEAFQAAAG8AAgACAAAAOyq0AAISBrkABAIAKrcA" +
+            "Byq0AAISCLkABAIAK7kACQEAKrQAAhIKuQAEAgAqtwALKrQAAhIMuQAEAgCxAAAAAQAWAAAAIgAI" +
+            "AAAAFQALABYADwAXABoAGAAgABkAKwAaAC8AGwA6ABwAAgAdAAAAAgAeADAAAAAKAAEADQAtAC8A" +
+            "CA==");
+    private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
+            "ZGV4CjAzNQBeEZYBAAAAAAAAAAAAAAAAAAAAAAAAAACMBgAAcAAAAHhWNBIAAAAAAAAAAMgFAAAi" +
+            "AAAAcAAAAAkAAAD4AAAABAAAABwBAAABAAAATAEAAAcAAABUAQAAAQAAAIwBAADgBAAArAEAAKwB" +
+            "AACvAQAAsgEAALoBAAC+AQAAxAEAAMwBAADtAQAADAIAACUCAAA0AgAAWAIAAHgCAACXAgAAqwIA" +
+            "AMECAADVAgAA8wIAABIDAAAZAwAAJwMAADIDAAA1AwAAOQMAAEEDAABOAwAAVAMAAIMDAACxAwAA" +
+            "3wMAAAwEAAAWBAAAGwQAACIEAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAAEQAAABUAAAAV" +
+            "AAAACAAAAAAAAAAWAAAACAAAADQEAAAWAAAACAAAADwEAAAWAAAACAAAACwEAAAAAAcAHgAAAAAA" +
+            "AwACAAAAAAAAAAUAAAAAAAAAEgAAAAAAAgAgAAAABQAAAAIAAAAGAAAAHwAAAAcAAQAXAAAAAAAA" +
+            "AAAAAAAFAAAAAAAAABMAAACoBQAARAUAAAAAAAABKAABPAAGPGluaXQ+AAI+OwAEPjspVgAGRmlu" +
+            "aXNoAB9Hb29kYnllIC0gcHJpdmF0ZSAtIFRyYW5zZm9ybWVkAB1IZWxsbyAtIHByaXZhdGUgLSBU" +
+            "cmFuc2Zvcm1lZAAXTGFydC9UZXN0OTE5JFRyYW5zZm9ybTsADUxhcnQvVGVzdDkxOTsAIkxkYWx2" +
+            "aWsvYW5ub3RhdGlvbi9FbmNsb3NpbmdDbGFzczsAHkxkYWx2aWsvYW5ub3RhdGlvbi9Jbm5lckNs" +
+            "YXNzOwAdTGRhbHZpay9hbm5vdGF0aW9uL1NpZ25hdHVyZTsAEkxqYXZhL2xhbmcvT2JqZWN0OwAU" +
+            "TGphdmEvbGFuZy9SdW5uYWJsZTsAEkxqYXZhL2xhbmcvU3RyaW5nOwAcTGphdmEvdXRpbC9mdW5j" +
+            "dGlvbi9Db25zdW1lcgAdTGphdmEvdXRpbC9mdW5jdGlvbi9Db25zdW1lcjsABVN0YXJ0AAxUZXN0" +
+            "OTE5LmphdmEACVRyYW5zZm9ybQABVgACVkwABmFjY2VwdAALYWNjZXNzRmxhZ3MABG5hbWUALXBv" +
+            "c3QgRmluaXNoIHByaXZhdGUgbWV0aG9kIGNhbGwgLSBUcmFuc2Zvcm1lZAAscG9zdCBTdGFydCBw" +
+            "cml2YXRlIG1ldGhvZCBjYWxsIC0gVHJhbnNmb3JtZWQALHByZSBGaW5pc2ggcHJpdmF0ZSBtZXRo" +
+            "b2QgY2FsbCAtIFRyYW5zZm9ybWVkACtwcmUgU3RhcnQgcHJpdmF0ZSBtZXRob2QgY2FsbCAtIFRy" +
+            "YW5zZm9ybWVkAAhyZXBvcnRlcgADcnVuAAVzYXlIaQAFdmFsdWUAAAAAAQAAAAcAAAABAAAABQAA" +
+            "AAEAAAAGAAAACAEABw4BAw8BAg8AEQAHDgEIDwANAAcOAQgPABUBAAcOAQgPAQMPAQgPAQMPAQgP" +
+            "AQMPAQgPAAACAAIAAQAAAEQEAAAGAAAAcBAEAAAAWwEAAA4AAwABAAIAAABQBAAACQAAAFQgAAAb" +
+            "AQYAAAByIAYAEAAOAAAAAwABAAIAAABYBAAACQAAAFQgAAAbAQcAAAByIAYAEAAOAAAABAACAAIA" +
+            "AABgBAAAKgAAAFQgAAAbAR0AAAByIAYAEABwEAIAAgBUIAAAGwEbAAAAciAGABAAchAFAAMAVCAA" +
+            "ABsBHAAAAHIgBgAQAHAQAQACAFQgAAAbARoAAAByIAYAEAAOAAABAwEAAgCBgAT8CAECmAkBArwJ" +
+            "AwHgCQICASEYAQIDAhgECBkXFAIEASEcBBcQFwEXDxcDAgQBIRwFFwAXEBcBFw8XBAAAAAIAAABc" +
+            "BQAAYgUAAAEAAABrBQAAAQAAAHkFAACMBQAAAQAAAAEAAAAAAAAAAAAAAJgFAAAAAAAAoAUAABAA" +
+            "AAAAAAAAAQAAAAAAAAABAAAAIgAAAHAAAAACAAAACQAAAPgAAAADAAAABAAAABwBAAAEAAAAAQAA" +
+            "AEwBAAAFAAAABwAAAFQBAAAGAAAAAQAAAIwBAAACIAAAIgAAAKwBAAABEAAAAwAAACwEAAADIAAA" +
+            "BAAAAEQEAAABIAAABAAAAHwEAAAAIAAAAQAAAEQFAAAEIAAABAAAAFwFAAADEAAAAwAAAIwFAAAG" +
+            "IAAAAQAAAKgFAAAAEAAAAQAAAMgFAAA=");
+
+    // A class that we can use to keep track of the output of this test.
+    private static class TestWatcher implements Consumer<String> {
+        private StringBuilder sb;
+        public TestWatcher() {
+            sb = new StringBuilder();
+        }
+
+        @Override
+        public void accept(String s) {
+            sb.append(s);
+            sb.append('\n');
+        }
+
+        public String getOutput() {
+            return sb.toString();
+        }
     }
 
-    @Override
-    public void accept(String s) {
-      sb.append(s);
-      sb.append('\n');
+    public static void run() {
+        Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
+        TestWatcher w = new TestWatcher();
+        doTest(new Transform(w), w);
     }
 
-    public String getOutput() {
-      return sb.toString();
+    public static void doTest(Transform t, TestWatcher w) {
+        Runnable do_redefinition = () -> {
+            w.accept("transforming calling function");
+            Redefinition.doCommonClassRedefinition(Transform.class, CLASS_BYTES, DEX_BYTES);
+        };
+        // This just prints something out to show we are running the Runnable.
+        Runnable say_nothing = () -> { w.accept("Not doing anything here"); };
+
+        // Try and redefine.
+        t.sayHi(say_nothing);
+        t.sayHi(do_redefinition);
+        t.sayHi(say_nothing);
+
+        // Print output of last run.
+        System.out.print(w.getOutput());
     }
-  }
-
-  public static void run() {
-    Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
-    TestWatcher w = new TestWatcher();
-    doTest(new Transform(w), w);
-  }
-
-  public static void doTest(Transform t, TestWatcher w) {
-    Runnable do_redefinition = () -> {
-      w.accept("transforming calling function");
-      Redefinition.doCommonClassRedefinition(Transform.class, CLASS_BYTES, DEX_BYTES);
-    };
-    // This just prints something out to show we are running the Runnable.
-    Runnable say_nothing = () -> { w.accept("Not doing anything here"); };
-
-    // Try and redefine.
-    t.sayHi(say_nothing);
-    t.sayHi(do_redefinition);
-    t.sayHi(say_nothing);
-
-    // Print output of last run.
-    System.out.print(w.getOutput());
-  }
 }