diff --git a/compiler/optimizing/graph_visualizer.cc b/compiler/optimizing/graph_visualizer.cc
index e0a9c6f..7ea1240 100644
--- a/compiler/optimizing/graph_visualizer.cc
+++ b/compiler/optimizing/graph_visualizer.cc
@@ -58,7 +58,7 @@
     if (is_empty_) {
       is_empty_ = false;
     } else {
-      sstream_ << " ";
+      sstream_ << ",";
     }
     return sstream_;
   }
@@ -71,7 +71,7 @@
 };
 
 std::ostream& operator<<(std::ostream& os, const StringList& list) {
-  return os << "[ " << list.sstream_.str() << " ]";
+  return os << "[" << list.sstream_.str() << "]";
 }
 
 /**
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index 1c3855f..8894d4e 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -19,7 +19,7 @@
   // CHECK-START: void Main.InlineVoid() inliner (before)
   // CHECK-DAG:     <<Const42:i\d+>> IntConstant 42
   // CHECK-DAG:                      InvokeStaticOrDirect
-  // CHECK-DAG:                      InvokeStaticOrDirect [ <<Const42>> ]
+  // CHECK-DAG:                      InvokeStaticOrDirect [<<Const42>>]
 
   // CHECK-START: void Main.InlineVoid() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
@@ -31,12 +31,12 @@
 
   // CHECK-START: int Main.InlineParameter(int) inliner (before)
   // CHECK-DAG:     <<Param:i\d+>>  ParameterValue
-  // CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect [ <<Param>> ]
-  // CHECK-DAG:                     Return [ <<Result>> ]
+  // CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>]
+  // CHECK-DAG:                     Return [<<Result>>]
 
   // CHECK-START: int Main.InlineParameter(int) inliner (after)
   // CHECK-DAG:     <<Param:i\d+>>  ParameterValue
-  // CHECK-DAG:                     Return [ <<Param>> ]
+  // CHECK-DAG:                     Return [<<Param>>]
 
   public static int InlineParameter(int a) {
     return returnParameter(a);
@@ -44,12 +44,12 @@
 
   // CHECK-START: long Main.InlineWideParameter(long) inliner (before)
   // CHECK-DAG:     <<Param:j\d+>>  ParameterValue
-  // CHECK-DAG:     <<Result:j\d+>> InvokeStaticOrDirect [ <<Param>> ]
-  // CHECK-DAG:                     Return [ <<Result>> ]
+  // CHECK-DAG:     <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>]
+  // CHECK-DAG:                     Return [<<Result>>]
 
   // CHECK-START: long Main.InlineWideParameter(long) inliner (after)
   // CHECK-DAG:     <<Param:j\d+>>  ParameterValue
-  // CHECK-DAG:                     Return [ <<Param>> ]
+  // CHECK-DAG:                     Return [<<Param>>]
 
   public static long InlineWideParameter(long a) {
     return returnWideParameter(a);
@@ -57,12 +57,12 @@
 
   // CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (before)
   // CHECK-DAG:     <<Param:l\d+>>  ParameterValue
-  // CHECK-DAG:     <<Result:l\d+>> InvokeStaticOrDirect [ <<Param>> ]
-  // CHECK-DAG:                     Return [ <<Result>> ]
+  // CHECK-DAG:     <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>]
+  // CHECK-DAG:                     Return [<<Result>>]
 
   // CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (after)
   // CHECK-DAG:     <<Param:l\d+>>  ParameterValue
-  // CHECK-DAG:                     Return [ <<Param>> ]
+  // CHECK-DAG:                     Return [<<Param>>]
 
   public static Object InlineReferenceParameter(Object o) {
     return returnReferenceParameter(o);
@@ -70,11 +70,11 @@
 
   // CHECK-START: int Main.InlineInt() inliner (before)
   // CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect
-  // CHECK-DAG:                     Return [ <<Result>> ]
+  // CHECK-DAG:                     Return [<<Result>>]
 
   // CHECK-START: int Main.InlineInt() inliner (after)
   // CHECK-DAG:     <<Const4:i\d+>> IntConstant 4
-  // CHECK-DAG:                     Return [ <<Const4>> ]
+  // CHECK-DAG:                     Return [<<Const4>>]
 
   public static int InlineInt() {
     return returnInt();
@@ -82,11 +82,11 @@
 
   // CHECK-START: long Main.InlineWide() inliner (before)
   // CHECK-DAG:     <<Result:j\d+>> InvokeStaticOrDirect
-  // CHECK-DAG:                     Return [ <<Result>> ]
+  // CHECK-DAG:                     Return [<<Result>>]
 
   // CHECK-START: long Main.InlineWide() inliner (after)
   // CHECK-DAG:     <<Const8:j\d+>> LongConstant 8
-  // CHECK-DAG:                     Return [ <<Const8>> ]
+  // CHECK-DAG:                     Return [<<Const8>>]
 
   public static long InlineWide() {
     return returnWide();
@@ -96,13 +96,13 @@
   // CHECK-DAG:     <<Const3:i\d+>> IntConstant 3
   // CHECK-DAG:     <<Const5:i\d+>> IntConstant 5
   // CHECK-DAG:     <<Result:i\d+>> InvokeStaticOrDirect
-  // CHECK-DAG:                     Return [ <<Result>> ]
+  // CHECK-DAG:                     Return [<<Result>>]
 
   // CHECK-START: int Main.InlineAdd() inliner (after)
   // CHECK-DAG:     <<Const3:i\d+>> IntConstant 3
   // CHECK-DAG:     <<Const5:i\d+>> IntConstant 5
-  // CHECK-DAG:     <<Add:i\d+>>    Add [ <<Const3>> <<Const5>> ]
-  // CHECK-DAG:                     Return [ <<Add>> ]
+  // CHECK-DAG:     <<Add:i\d+>>    Add [<<Const3>>,<<Const5>>]
+  // CHECK-DAG:                     Return [<<Add>>]
 
   public static int InlineAdd() {
     return returnAdd(3, 5);
@@ -110,14 +110,14 @@
 
   // CHECK-START: int Main.InlineFieldAccess() inliner (before)
   // CHECK-DAG:     <<After:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                     Return [ <<After>> ]
+  // CHECK-DAG:                     Return [<<After>>]
 
   // CHECK-START: int Main.InlineFieldAccess() inliner (after)
   // CHECK-DAG:     <<Const1:i\d+>> IntConstant 1
   // CHECK-DAG:     <<Before:i\d+>> StaticFieldGet
-  // CHECK-DAG:     <<After:i\d+>>  Add [ <<Before>> <<Const1>> ]
-  // CHECK-DAG:                     StaticFieldSet [ {{l\d+}} <<After>> ]
-  // CHECK-DAG:                     Return [ <<After>> ]
+  // CHECK-DAG:     <<After:i\d+>>  Add [<<Before>>,<<Const1>>]
+  // CHECK-DAG:                     StaticFieldSet [{{l\d+}},<<After>>]
+  // CHECK-DAG:                     Return [<<After>>]
 
   // CHECK-START: int Main.InlineFieldAccess() inliner (after)
   // CHECK-NOT:                     InvokeStaticOrDirect
@@ -130,19 +130,19 @@
   // CHECK-DAG:     <<Const1:i\d+>> IntConstant 1
   // CHECK-DAG:     <<Const3:i\d+>> IntConstant 3
   // CHECK-DAG:     <<Const5:i\d+>> IntConstant 5
-  // CHECK-DAG:     <<Add:i\d+>>    InvokeStaticOrDirect [ <<Const1>> <<Const3>> ]
-  // CHECK-DAG:     <<Sub:i\d+>>    InvokeStaticOrDirect [ <<Const5>> <<Const3>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>    Phi [ <<Add>> <<Sub>> ]
-  // CHECK-DAG:                     Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Add:i\d+>>    InvokeStaticOrDirect [<<Const1>>,<<Const3>>]
+  // CHECK-DAG:     <<Sub:i\d+>>    InvokeStaticOrDirect [<<Const5>>,<<Const3>>]
+  // CHECK-DAG:     <<Phi:i\d+>>    Phi [<<Add>>,<<Sub>>]
+  // CHECK-DAG:                     Return [<<Phi>>]
 
   // CHECK-START: int Main.InlineWithControlFlow(boolean) inliner (after)
   // CHECK-DAG:     <<Const1:i\d+>> IntConstant 1
   // CHECK-DAG:     <<Const3:i\d+>> IntConstant 3
   // CHECK-DAG:     <<Const5:i\d+>> IntConstant 5
-  // CHECK-DAG:     <<Add:i\d+>>    Add [ <<Const1>> <<Const3>> ]
-  // CHECK-DAG:     <<Sub:i\d+>>    Sub [ <<Const5>> <<Const3>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>    Phi [ <<Add>> <<Sub>> ]
-  // CHECK-DAG:                     Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Add:i\d+>>    Add [<<Const1>>,<<Const3>>]
+  // CHECK-DAG:     <<Sub:i\d+>>    Sub [<<Const5>>,<<Const3>>]
+  // CHECK-DAG:     <<Phi:i\d+>>    Phi [<<Add>>,<<Sub>>]
+  // CHECK-DAG:                     Return [<<Phi>>]
 
   public static int InlineWithControlFlow(boolean cond) {
     int x, const1, const3, const5;
diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java
index 9a2e4fc..c258db9 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -53,12 +53,12 @@
 
   // CHECK-START: int Main.IntNegation() constant_folding (before)
   // CHECK-DAG:     <<Const42:i\d+>>  IntConstant 42
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Const42>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Const42>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   // CHECK-START: int Main.IntNegation() constant_folding (after)
   // CHECK-DAG:     <<ConstN42:i\d+>> IntConstant -42
-  // CHECK-DAG:                       Return [ <<ConstN42>> ]
+  // CHECK-DAG:                       Return [<<ConstN42>>]
 
   public static int IntNegation() {
     int x, y;
@@ -75,12 +75,12 @@
   // CHECK-START: int Main.IntAddition1() constant_folding (before)
   // CHECK-DAG:     <<Const1:i\d+>>  IntConstant 1
   // CHECK-DAG:     <<Const2:i\d+>>  IntConstant 2
-  // CHECK-DAG:     <<Add:i\d+>>     Add [ <<Const1>> <<Const2>> ]
-  // CHECK-DAG:                      Return [ <<Add>> ]
+  // CHECK-DAG:     <<Add:i\d+>>     Add [<<Const1>>,<<Const2>>]
+  // CHECK-DAG:                      Return [<<Add>>]
 
   // CHECK-START: int Main.IntAddition1() constant_folding (after)
   // CHECK-DAG:     <<Const3:i\d+>>  IntConstant 3
-  // CHECK-DAG:                      Return [ <<Const3>> ]
+  // CHECK-DAG:                      Return [<<Const3>>]
 
   public static int IntAddition1() {
     int a, b, c;
@@ -100,14 +100,14 @@
   // CHECK-DAG:     <<Const2:i\d+>>  IntConstant 2
   // CHECK-DAG:     <<Const5:i\d+>>  IntConstant 5
   // CHECK-DAG:     <<Const6:i\d+>>  IntConstant 6
-  // CHECK-DAG:     <<Add1:i\d+>>    Add [ <<Const1>> <<Const2>> ]
-  // CHECK-DAG:     <<Add2:i\d+>>    Add [ <<Const5>> <<Const6>> ]
-  // CHECK-DAG:     <<Add3:i\d+>>    Add [ <<Add1>> <<Add2>> ]
-  // CHECK-DAG:                      Return [ <<Add3>> ]
+  // CHECK-DAG:     <<Add1:i\d+>>    Add [<<Const1>>,<<Const2>>]
+  // CHECK-DAG:     <<Add2:i\d+>>    Add [<<Const5>>,<<Const6>>]
+  // CHECK-DAG:     <<Add3:i\d+>>    Add [<<Add1>>,<<Add2>>]
+  // CHECK-DAG:                      Return [<<Add3>>]
 
   // CHECK-START: int Main.IntAddition2() constant_folding (after)
   // CHECK-DAG:     <<Const14:i\d+>> IntConstant 14
-  // CHECK-DAG:                      Return [ <<Const14>> ]
+  // CHECK-DAG:                      Return [<<Const14>>]
 
   public static int IntAddition2() {
     int a, b, c;
@@ -129,12 +129,12 @@
   // CHECK-START: int Main.IntSubtraction() constant_folding (before)
   // CHECK-DAG:     <<Const6:i\d+>>  IntConstant 6
   // CHECK-DAG:     <<Const2:i\d+>>  IntConstant 2
-  // CHECK-DAG:     <<Sub:i\d+>>     Sub [ <<Const6>> <<Const2>> ]
-  // CHECK-DAG:                      Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>     Sub [<<Const6>>,<<Const2>>]
+  // CHECK-DAG:                      Return [<<Sub>>]
 
   // CHECK-START: int Main.IntSubtraction() constant_folding (after)
   // CHECK-DAG:     <<Const4:i\d+>>  IntConstant 4
-  // CHECK-DAG:                      Return [ <<Const4>> ]
+  // CHECK-DAG:                      Return [<<Const4>>]
 
   public static int IntSubtraction() {
     int a, b, c;
@@ -152,12 +152,12 @@
   // CHECK-START: long Main.LongAddition() constant_folding (before)
   // CHECK-DAG:     <<Const1:j\d+>>  LongConstant 1
   // CHECK-DAG:     <<Const2:j\d+>>  LongConstant 2
-  // CHECK-DAG:     <<Add:j\d+>>     Add [ <<Const1>> <<Const2>> ]
-  // CHECK-DAG:                      Return [ <<Add>> ]
+  // CHECK-DAG:     <<Add:j\d+>>     Add [<<Const1>>,<<Const2>>]
+  // CHECK-DAG:                      Return [<<Add>>]
 
   // CHECK-START: long Main.LongAddition() constant_folding (after)
   // CHECK-DAG:     <<Const3:j\d+>>  LongConstant 3
-  // CHECK-DAG:                      Return [ <<Const3>> ]
+  // CHECK-DAG:                      Return [<<Const3>>]
 
   public static long LongAddition() {
     long a, b, c;
@@ -175,12 +175,12 @@
   // CHECK-START: long Main.LongSubtraction() constant_folding (before)
   // CHECK-DAG:     <<Const6:j\d+>>  LongConstant 6
   // CHECK-DAG:     <<Const2:j\d+>>  LongConstant 2
-  // CHECK-DAG:     <<Sub:j\d+>>     Sub [ <<Const6>> <<Const2>> ]
-  // CHECK-DAG:                      Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:j\d+>>     Sub [<<Const6>>,<<Const2>>]
+  // CHECK-DAG:                      Return [<<Sub>>]
 
   // CHECK-START: long Main.LongSubtraction() constant_folding (after)
   // CHECK-DAG:     <<Const4:j\d+>>  LongConstant 4
-  // CHECK-DAG:                      Return [ <<Const4>> ]
+  // CHECK-DAG:                      Return [<<Const4>>]
 
   public static long LongSubtraction() {
     long a, b, c;
@@ -197,12 +197,12 @@
   // CHECK-START: int Main.StaticCondition() constant_folding (before)
   // CHECK-DAG:     <<Const7:i\d+>>  IntConstant 7
   // CHECK-DAG:     <<Const2:i\d+>>  IntConstant 2
-  // CHECK-DAG:     <<Cond:z\d+>>    GreaterThanOrEqual [ <<Const7>> <<Const2>> ]
-  // CHECK-DAG:                      If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>    GreaterThanOrEqual [<<Const7>>,<<Const2>>]
+  // CHECK-DAG:                      If [<<Cond>>]
 
   // CHECK-START: int Main.StaticCondition() constant_folding (after)
   // CHECK-DAG:     <<Const1:i\d+>>  IntConstant 1
-  // CHECK-DAG:                      If [ <<Const1>> ]
+  // CHECK-DAG:                      If [<<Const1>>]
 
   public static int StaticCondition() {
     int a, b, c;
@@ -227,16 +227,16 @@
   // CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (before)
   // CHECK-DAG:     <<Const2:i\d+>>  IntConstant 2
   // CHECK-DAG:     <<Const5:i\d+>>  IntConstant 5
-  // CHECK-DAG:     <<Add:i\d+>>     Add [ <<Const5>> <<Const2>> ]
-  // CHECK-DAG:     <<Sub:i\d+>>     Sub [ <<Const5>> <<Const2>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>     Phi [ <<Add>> <<Sub>> ]
-  // CHECK-DAG:                      Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Add:i\d+>>     Add [<<Const5>>,<<Const2>>]
+  // CHECK-DAG:     <<Sub:i\d+>>     Sub [<<Const5>>,<<Const2>>]
+  // CHECK-DAG:     <<Phi:i\d+>>     Phi [<<Add>>,<<Sub>>]
+  // CHECK-DAG:                      Return [<<Phi>>]
 
   // CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding (after)
   // CHECK-DAG:     <<Const3:i\d+>>  IntConstant 3
   // CHECK-DAG:     <<Const7:i\d+>>  IntConstant 7
-  // CHECK-DAG:     <<Phi:i\d+>>     Phi [ <<Const7>> <<Const3>> ]
-  // CHECK-DAG:                      Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Phi:i\d+>>     Phi [<<Const7>>,<<Const3>>]
+  // CHECK-DAG:                      Return [<<Phi>>]
 
   public static int JumpsAndConditionals(boolean cond) {
     int a, b, c;
@@ -256,14 +256,14 @@
   // CHECK-START: int Main.And0(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<And:i\d+>>      And [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<And>> ]
+  // CHECK-DAG:     <<And:i\d+>>      And [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<And>>]
 
   // CHECK-START: int Main.And0(int) constant_folding (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-NOT:                       And
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static int And0(int arg) {
     return arg & 0;
@@ -272,14 +272,14 @@
   // CHECK-START: long Main.Mul0(long) constant_folding (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
-  // CHECK-DAG:     <<Mul:j\d+>>      Mul [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Mul>> ]
+  // CHECK-DAG:     <<Mul:j\d+>>      Mul [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Mul>>]
 
   // CHECK-START: long Main.Mul0(long) constant_folding (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
   // CHECK-NOT:                       Mul
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static long Mul0(long arg) {
     return arg * 0;
@@ -288,13 +288,13 @@
   // CHECK-START: int Main.OrAllOnes(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<ConstF:i\d+>>   IntConstant -1
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Arg>> <<ConstF>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Arg>>,<<ConstF>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.OrAllOnes(int) constant_folding (after)
   // CHECK-DAG:     <<ConstF:i\d+>>   IntConstant -1
   // CHECK-NOT:                       Or
-  // CHECK-DAG:                       Return [ <<ConstF>> ]
+  // CHECK-DAG:                       Return [<<ConstF>>]
 
   public static int OrAllOnes(int arg) {
     return arg | -1;
@@ -303,14 +303,14 @@
   // CHECK-START: long Main.Rem0(long) constant_folding (before)
   // CHECK-DAG:     <<Arg:j\d+>>           ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>        LongConstant 0
-  // CHECK-DAG:     <<DivZeroCheck:j\d+>>  DivZeroCheck [ <<Arg>> ]
-  // CHECK-DAG:     <<Rem:j\d+>>           Rem [ <<Const0>> <<DivZeroCheck>> ]
-  // CHECK-DAG:                            Return [ <<Rem>> ]
+  // CHECK-DAG:     <<DivZeroCheck:j\d+>>  DivZeroCheck [<<Arg>>]
+  // CHECK-DAG:     <<Rem:j\d+>>           Rem [<<Const0>>,<<DivZeroCheck>>]
+  // CHECK-DAG:                            Return [<<Rem>>]
 
   // CHECK-START: long Main.Rem0(long) constant_folding (after)
   // CHECK-DAG:     <<Const0:j\d+>>        LongConstant 0
   // CHECK-NOT:                            Rem
-  // CHECK-DAG:                            Return [ <<Const0>> ]
+  // CHECK-DAG:                            Return [<<Const0>>]
 
   public static long Rem0(long arg) {
     return 0 % arg;
@@ -319,13 +319,13 @@
   // CHECK-START: int Main.Rem1(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Rem:i\d+>>      Rem [ <<Arg>> <<Const1>> ]
-  // CHECK-DAG:                       Return [ <<Rem>> ]
+  // CHECK-DAG:     <<Rem:i\d+>>      Rem [<<Arg>>,<<Const1>>]
+  // CHECK-DAG:                       Return [<<Rem>>]
 
   // CHECK-START: int Main.Rem1(int) constant_folding (after)
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-NOT:                       Rem
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static int Rem1(int arg) {
     return arg % 1;
@@ -334,14 +334,14 @@
   // CHECK-START: long Main.RemN1(long) constant_folding (before)
   // CHECK-DAG:     <<Arg:j\d+>>           ParameterValue
   // CHECK-DAG:     <<ConstN1:j\d+>>       LongConstant -1
-  // CHECK-DAG:     <<DivZeroCheck:j\d+>>  DivZeroCheck [ <<Arg>> ]
-  // CHECK-DAG:     <<Rem:j\d+>>           Rem [ <<Arg>> <<DivZeroCheck>> ]
-  // CHECK-DAG:                            Return [ <<Rem>> ]
+  // CHECK-DAG:     <<DivZeroCheck:j\d+>>  DivZeroCheck [<<ConstN1>>]
+  // CHECK-DAG:     <<Rem:j\d+>>           Rem [<<Arg>>,<<DivZeroCheck>>]
+  // CHECK-DAG:                            Return [<<Rem>>]
 
   // CHECK-START: long Main.RemN1(long) constant_folding (after)
   // CHECK-DAG:     <<Const0:j\d+>>        LongConstant 0
   // CHECK-NOT:                            Rem
-  // CHECK-DAG:                            Return [ <<Const0>> ]
+  // CHECK-DAG:                            Return [<<Const0>>]
 
   public static long RemN1(long arg) {
     return arg % -1;
@@ -350,14 +350,14 @@
   // CHECK-START: int Main.Shl0(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Shl:i\d+>>      Shl [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Shl>> ]
+  // CHECK-DAG:     <<Shl:i\d+>>      Shl [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Shl>>]
 
   // CHECK-START: int Main.Shl0(int) constant_folding (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-NOT:                       Shl
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static int Shl0(int arg) {
     return 0 << arg;
@@ -366,14 +366,14 @@
   // CHECK-START: long Main.Shr0(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
-  // CHECK-DAG:     <<Shr:j\d+>>      Shr [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Shr>> ]
+  // CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Shr>>]
 
   // CHECK-START: long Main.Shr0(int) constant_folding (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
   // CHECK-NOT:                       Shr
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static long Shr0(int arg) {
     return (long)0 >> arg;
@@ -381,14 +381,14 @@
 
   // CHECK-START: long Main.SubSameLong(long) constant_folding (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:     <<Sub:j\d+>>      Sub [ <<Arg>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Arg>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: long Main.SubSameLong(long) constant_folding (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
   // CHECK-NOT:                       Sub
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static long SubSameLong(long arg) {
     return arg - arg;
@@ -397,14 +397,14 @@
   // CHECK-START: int Main.UShr0(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<UShr:i\d+>>     UShr [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<UShr>> ]
+  // CHECK-DAG:     <<UShr:i\d+>>     UShr [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<UShr>>]
 
   // CHECK-START: int Main.UShr0(int) constant_folding (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-NOT:                       UShr
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static int UShr0(int arg) {
     return 0 >>> arg;
@@ -412,14 +412,14 @@
 
   // CHECK-START: int Main.XorSameInt(int) constant_folding (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Xor:i\d+>>      Xor [ <<Arg>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Xor>> ]
+  // CHECK-DAG:     <<Xor:i\d+>>      Xor [<<Arg>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Xor>>]
 
   // CHECK-START: int Main.XorSameInt(int) constant_folding (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-NOT:                       Xor
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static int XorSameInt(int arg) {
     return arg ^ arg;
@@ -430,16 +430,16 @@
   // CHECK-DAG:     <<ConstNan:f\d+>> FloatConstant nan
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:                       IntConstant 1
-  // CHECK-DAG:     <<Cmp:i\d+>>      Compare [ <<Arg>> <<ConstNan>> ]
-  // CHECK-DAG:     <<Le:z\d+>>       LessThanOrEqual [ <<Cmp>> <<Const0>> ]
-  // CHECK-DAG:                       If [ <<Le>> ]
+  // CHECK-DAG:     <<Cmp:i\d+>>      Compare [<<Arg>>,<<ConstNan>>]
+  // CHECK-DAG:     <<Le:z\d+>>       LessThanOrEqual [<<Cmp>>,<<Const0>>]
+  // CHECK-DAG:                       If [<<Le>>]
 
   // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
   // CHECK-DAG:                       ParameterValue
   // CHECK-DAG:                       FloatConstant nan
   // CHECK-DAG:                       IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:                       If [ <<Const1>> ]
+  // CHECK-DAG:                       If [<<Const1>>]
 
   // CHECK-START: boolean Main.CmpFloatGreaterThanNaN(float) constant_folding (after)
   // CHECK-NOT:                       Compare
@@ -454,16 +454,16 @@
   // CHECK-DAG:     <<ConstNan:d\d+>> DoubleConstant nan
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:                       IntConstant 1
-  // CHECK-DAG:     <<Cmp:i\d+>>      Compare [ <<Arg>> <<ConstNan>> ]
-  // CHECK-DAG:     <<Ge:z\d+>>       GreaterThanOrEqual [ <<Cmp>> <<Const0>> ]
-  // CHECK-DAG:                       If [ <<Ge>> ]
+  // CHECK-DAG:     <<Cmp:i\d+>>      Compare [<<Arg>>,<<ConstNan>>]
+  // CHECK-DAG:     <<Ge:z\d+>>       GreaterThanOrEqual [<<Cmp>>,<<Const0>>]
+  // CHECK-DAG:                       If [<<Ge>>]
 
   // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
   // CHECK-DAG:                       ParameterValue
   // CHECK-DAG:                       DoubleConstant nan
   // CHECK-DAG:                       IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:                       If [ <<Const1>> ]
+  // CHECK-DAG:                       If [<<Const1>>]
 
   // CHECK-START: boolean Main.CmpDoubleLessThanNaN(double) constant_folding (after)
   // CHECK-NOT:                       Compare
@@ -475,12 +475,12 @@
 
   // CHECK-START: int Main.ReturnInt33() constant_folding (before)
   // CHECK-DAG:     <<Const33:j\d+>>  LongConstant 33
-  // CHECK-DAG:     <<Convert:i\d+>>  TypeConversion <<Const33>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:i\d+>>  TypeConversion [<<Const33>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: int Main.ReturnInt33() constant_folding (after)
   // CHECK-DAG:     <<Const33:i\d+>>  IntConstant 33
-  // CHECK-DAG:                       Return [ <<Const33>> ]
+  // CHECK-DAG:                       Return [<<Const33>>]
 
   public static int ReturnInt33() {
     long imm = 33L;
@@ -489,12 +489,12 @@
 
   // CHECK-START: int Main.ReturnIntMax() constant_folding (before)
   // CHECK-DAG:     <<ConstMax:f\d+>> FloatConstant 1e+34
-  // CHECK-DAG:     <<Convert:i\d+>>  TypeConversion <<ConstMax>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:i\d+>>  TypeConversion [<<ConstMax>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: int Main.ReturnIntMax() constant_folding (after)
   // CHECK-DAG:     <<ConstMax:i\d+>> IntConstant 2147483647
-  // CHECK-DAG:                       Return [ <<ConstMax>> ]
+  // CHECK-DAG:                       Return [<<ConstMax>>]
 
   public static int ReturnIntMax() {
     float imm = 1.0e34f;
@@ -503,12 +503,12 @@
 
   // CHECK-START: int Main.ReturnInt0() constant_folding (before)
   // CHECK-DAG:     <<ConstNaN:d\d+>> DoubleConstant nan
-  // CHECK-DAG:     <<Convert:i\d+>>  TypeConversion <<ConstNaN>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:i\d+>>  TypeConversion [<<ConstNaN>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: int Main.ReturnInt0() constant_folding (after)
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static int ReturnInt0() {
     double imm = Double.NaN;
@@ -517,12 +517,12 @@
 
   // CHECK-START: long Main.ReturnLong33() constant_folding (before)
   // CHECK-DAG:     <<Const33:i\d+>>  IntConstant 33
-  // CHECK-DAG:     <<Convert:j\d+>>  TypeConversion <<Const33>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:j\d+>>  TypeConversion [<<Const33>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: long Main.ReturnLong33() constant_folding (after)
   // CHECK-DAG:     <<Const33:j\d+>>  LongConstant 33
-  // CHECK-DAG:                       Return [ <<Const33>> ]
+  // CHECK-DAG:                       Return [<<Const33>>]
 
   public static long ReturnLong33() {
     int imm = 33;
@@ -531,12 +531,12 @@
 
   // CHECK-START: long Main.ReturnLong34() constant_folding (before)
   // CHECK-DAG:     <<Const34:f\d+>>  FloatConstant 34
-  // CHECK-DAG:     <<Convert:j\d+>>  TypeConversion <<Const34>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:j\d+>>  TypeConversion [<<Const34>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: long Main.ReturnLong34() constant_folding (after)
   // CHECK-DAG:     <<Const34:j\d+>>  LongConstant 34
-  // CHECK-DAG:                       Return [ <<Const34>> ]
+  // CHECK-DAG:                       Return [<<Const34>>]
 
   public static long ReturnLong34() {
     float imm = 34.0f;
@@ -545,12 +545,12 @@
 
   // CHECK-START: long Main.ReturnLong0() constant_folding (before)
   // CHECK-DAG:     <<ConstNaN:d\d+>> DoubleConstant nan
-  // CHECK-DAG:     <<Convert:j\d+>>  TypeConversion <<ConstNaN>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:j\d+>>  TypeConversion [<<ConstNaN>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: long Main.ReturnLong0() constant_folding (after)
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
-  // CHECK-DAG:                       Return [ <<Const0>> ]
+  // CHECK-DAG:                       Return [<<Const0>>]
 
   public static long ReturnLong0() {
     double imm = -Double.NaN;
@@ -559,12 +559,12 @@
 
   // CHECK-START: float Main.ReturnFloat33() constant_folding (before)
   // CHECK-DAG:     <<Const33:i\d+>>  IntConstant 33
-  // CHECK-DAG:     <<Convert:f\d+>>  TypeConversion <<Const33>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:f\d+>>  TypeConversion [<<Const33>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: float Main.ReturnFloat33() constant_folding (after)
   // CHECK-DAG:     <<Const33:f\d+>>  FloatConstant 33
-  // CHECK-DAG:                       Return [ <<Const33>> ]
+  // CHECK-DAG:                       Return [<<Const33>>]
 
   public static float ReturnFloat33() {
     int imm = 33;
@@ -573,12 +573,12 @@
 
   // CHECK-START: float Main.ReturnFloat34() constant_folding (before)
   // CHECK-DAG:     <<Const34:j\d+>>  LongConstant 34
-  // CHECK-DAG:     <<Convert:f\d+>>  TypeConversion <<Const34>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:f\d+>>  TypeConversion [<<Const34>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: float Main.ReturnFloat34() constant_folding (after)
   // CHECK-DAG:     <<Const34:f\d+>>  FloatConstant 34
-  // CHECK-DAG:                       Return [ <<Const34>> ]
+  // CHECK-DAG:                       Return [<<Const34>>]
 
   public static float ReturnFloat34() {
     long imm = 34L;
@@ -587,12 +587,12 @@
 
   // CHECK-START: float Main.ReturnFloat99P25() constant_folding (before)
   // CHECK-DAG:     <<Const:d\d+>>    DoubleConstant 99.25
-  // CHECK-DAG:     <<Convert:f\d+>>  TypeConversion <<Const>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:f\d+>>  TypeConversion [<<Const>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: float Main.ReturnFloat99P25() constant_folding (after)
   // CHECK-DAG:     <<Const:f\d+>>    FloatConstant 99.25
-  // CHECK-DAG:                       Return [ <<Const>> ]
+  // CHECK-DAG:                       Return [<<Const>>]
 
   public static float ReturnFloat99P25() {
     double imm = 99.25;
@@ -601,12 +601,12 @@
 
   // CHECK-START: double Main.ReturnDouble33() constant_folding (before)
   // CHECK-DAG:     <<Const33:i\d+>>  IntConstant 33
-  // CHECK-DAG:     <<Convert:d\d+>>  TypeConversion <<Const33>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:d\d+>>  TypeConversion [<<Const33>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: double Main.ReturnDouble33() constant_folding (after)
   // CHECK-DAG:     <<Const33:d\d+>>  DoubleConstant 33
-  // CHECK-DAG:                       Return [ <<Const33>> ]
+  // CHECK-DAG:                       Return [<<Const33>>]
 
   public static double ReturnDouble33() {
     int imm = 33;
@@ -615,12 +615,12 @@
 
   // CHECK-START: double Main.ReturnDouble34() constant_folding (before)
   // CHECK-DAG:     <<Const34:j\d+>>  LongConstant 34
-  // CHECK-DAG:     <<Convert:d\d+>>  TypeConversion <<Const34>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:d\d+>>  TypeConversion [<<Const34>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: double Main.ReturnDouble34() constant_folding (after)
   // CHECK-DAG:     <<Const34:d\d+>>  DoubleConstant 34
-  // CHECK-DAG:                       Return [ <<Const34>> ]
+  // CHECK-DAG:                       Return [<<Const34>>]
 
   public static double ReturnDouble34() {
     long imm = 34L;
@@ -629,12 +629,12 @@
 
   // CHECK-START: double Main.ReturnDouble99P25() constant_folding (before)
   // CHECK-DAG:     <<Const:f\d+>>    FloatConstant 99.25
-  // CHECK-DAG:     <<Convert:d\d+>>  TypeConversion <<Const>>
-  // CHECK-DAG:                       Return [ <<Convert>> ]
+  // CHECK-DAG:     <<Convert:d\d+>>  TypeConversion [<<Const>>]
+  // CHECK-DAG:                       Return [<<Convert>>]
 
   // CHECK-START: double Main.ReturnDouble99P25() constant_folding (after)
   // CHECK-DAG:     <<Const:d\d+>>    DoubleConstant 99.25
-  // CHECK-DAG:                       Return [ <<Const>> ]
+  // CHECK-DAG:                       Return [<<Const>>]
 
   public static double ReturnDouble99P25() {
     float imm = 99.25f;
diff --git a/test/445-checker-licm/src/Main.java b/test/445-checker-licm/src/Main.java
index ce2ab9a..96918d3 100644
--- a/test/445-checker-licm/src/Main.java
+++ b/test/445-checker-licm/src/Main.java
@@ -89,7 +89,7 @@
 
   // CHECK-START: int Main.arrayLength(int[]) licm (before)
   // CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:{{B\d+}}
-  // CHECK-DAG:                    ArrayLength [ <<NullCheck>> ] loop:{{B\d+}}
+  // CHECK-DAG:                    ArrayLength [<<NullCheck>>] loop:{{B\d+}}
 
   // CHECK-START: int Main.arrayLength(int[]) licm (after)
   // CHECK-NOT:                    NullCheck loop:{{B\d+}}
@@ -97,7 +97,7 @@
 
   // CHECK-START: int Main.arrayLength(int[]) licm (after)
   // CHECK-DAG: <<NullCheck:l\d+>> NullCheck loop:none
-  // CHECK-DAG:                    ArrayLength [ <<NullCheck>> ] loop:none
+  // CHECK-DAG:                    ArrayLength [<<NullCheck>>] loop:none
 
   public static int arrayLength(int[] array) {
     int result = 0;
diff --git a/test/446-checker-inliner2/src/Main.java b/test/446-checker-inliner2/src/Main.java
index 5d4ddf8..9ed66d6 100644
--- a/test/446-checker-inliner2/src/Main.java
+++ b/test/446-checker-inliner2/src/Main.java
@@ -18,14 +18,14 @@
 
   // CHECK-START: int Main.inlineInstanceCall(Main) inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: int Main.inlineInstanceCall(Main) inliner (after)
   // CHECK-DAG:     <<Field:i\d+>>   InstanceFieldGet
-  // CHECK-DAG:                      Return [ <<Field>> ]
+  // CHECK-DAG:                      Return [<<Field>>]
 
   public static int inlineInstanceCall(Main m) {
     return m.foo();
@@ -39,14 +39,14 @@
 
   // CHECK-START: int Main.inlineNestedCall() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.inlineNestedCall() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: int Main.inlineNestedCall() inliner (after)
   // CHECK-DAG:     <<Const38:i\d+>> IntConstant 38
-  // CHECK-DAG:                      Return [ <<Const38>> ]
+  // CHECK-DAG:                      Return [<<Const38>>]
 
   public static int inlineNestedCall() {
     return nestedCall();
diff --git a/test/447-checker-inliner3/src/Main.java b/test/447-checker-inliner3/src/Main.java
index 34faafa..9d022b9 100644
--- a/test/447-checker-inliner3/src/Main.java
+++ b/test/447-checker-inliner3/src/Main.java
@@ -18,7 +18,7 @@
 
   // CHECK-START: int Main.inlineIfThenElse() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.inlineIfThenElse() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index ebad8e5..742210c 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -53,12 +53,12 @@
   // CHECK-START: long Main.Add0(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>  LongConstant 0
-  // CHECK-DAG:     <<Add:j\d+>>     Add [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                      Return [ <<Add>> ]
+  // CHECK-DAG:     <<Add:j\d+>>     Add [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                      Return [<<Add>>]
 
   // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
-  // CHECK-DAG:                      Return [ <<Arg>> ]
+  // CHECK-DAG:                      Return [<<Arg>>]
 
   // CHECK-START: long Main.Add0(long) instruction_simplifier (after)
   // CHECK-NOT:                        Add
@@ -70,12 +70,12 @@
   // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>     ParameterValue
   // CHECK-DAG:     <<ConstF:i\d+>>  IntConstant -1
-  // CHECK-DAG:     <<And:i\d+>>     And [ <<Arg>> <<ConstF>> ]
-  // CHECK-DAG:                      Return [ <<And>> ]
+  // CHECK-DAG:     <<And:i\d+>>     And [<<Arg>>,<<ConstF>>]
+  // CHECK-DAG:                      Return [<<And>>]
 
   // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>     ParameterValue
-  // CHECK-DAG:                      Return [ <<Arg>> ]
+  // CHECK-DAG:                      Return [<<Arg>>]
 
   // CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
   // CHECK-NOT:                      And
@@ -87,12 +87,12 @@
   // CHECK-START: long Main.Div1(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Const1:j\d+>>  LongConstant 1
-  // CHECK-DAG:     <<Div:j\d+>>     Div [ <<Arg>> <<Const1>> ]
-  // CHECK-DAG:                      Return [ <<Div>> ]
+  // CHECK-DAG:     <<Div:j\d+>>     Div [<<Arg>>,<<Const1>>]
+  // CHECK-DAG:                      Return [<<Div>>]
 
   // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
-  // CHECK-DAG:                      Return [ <<Arg>> ]
+  // CHECK-DAG:                      Return [<<Arg>>]
 
   // CHECK-START: long Main.Div1(long) instruction_simplifier (after)
   // CHECK-NOT:                      Div
@@ -104,13 +104,13 @@
   // CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<ConstN1:i\d+>>  IntConstant -1
-  // CHECK-DAG:     <<Div:i\d+>>      Div [ <<Arg>> <<ConstN1>> ]
-  // CHECK-DAG:                       Return [ <<Div>> ]
+  // CHECK-DAG:     <<Div:i\d+>>      Div [<<Arg>>,<<ConstN1>>]
+  // CHECK-DAG:                       Return [<<Div>>]
 
   // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   // CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
   // CHECK-NOT:                       Div
@@ -122,12 +122,12 @@
   // CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Const1:j\d+>>  LongConstant 1
-  // CHECK-DAG:     <<Mul:j\d+>>     Mul [ <<Arg>> <<Const1>> ]
-  // CHECK-DAG:                      Return [ <<Mul>> ]
+  // CHECK-DAG:     <<Mul:j\d+>>     Mul [<<Arg>>,<<Const1>>]
+  // CHECK-DAG:                      Return [<<Mul>>]
 
   // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
-  // CHECK-DAG:                      Return [ <<Arg>> ]
+  // CHECK-DAG:                      Return [<<Arg>>]
 
   // CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
   // CHECK-NOT:                       Mul
@@ -139,13 +139,13 @@
   // CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<ConstN1:i\d+>>  IntConstant -1
-  // CHECK-DAG:     <<Mul:i\d+>>      Mul [ <<Arg>> <<ConstN1>> ]
-  // CHECK-DAG:                       Return [ <<Mul>> ]
+  // CHECK-DAG:     <<Mul:i\d+>>      Mul [<<Arg>>,<<ConstN1>>]
+  // CHECK-DAG:                       Return [<<Mul>>]
 
   // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   // CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
   // CHECK-NOT:                       Mul
@@ -157,14 +157,14 @@
   // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
   // CHECK-DAG:     <<Const128:j\d+>>  LongConstant 128
-  // CHECK-DAG:     <<Mul:j\d+>>       Mul [ <<Arg>> <<Const128>> ]
-  // CHECK-DAG:                        Return [ <<Mul>> ]
+  // CHECK-DAG:     <<Mul:j\d+>>       Mul [<<Arg>>,<<Const128>>]
+  // CHECK-DAG:                        Return [<<Mul>>]
 
   // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
   // CHECK-DAG:     <<Const7:i\d+>>    IntConstant 7
-  // CHECK-DAG:     <<Shl:j\d+>>       Shl [ <<Arg>> <<Const7>> ]
-  // CHECK-DAG:                        Return [ <<Shl>> ]
+  // CHECK-DAG:     <<Shl:j\d+>>       Shl [<<Arg>>,<<Const7>>]
+  // CHECK-DAG:                        Return [<<Shl>>]
 
   // CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
   // CHECK-NOT:                        Mul
@@ -176,12 +176,12 @@
   // CHECK-START: int Main.Or0(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: int Main.Or0(int) instruction_simplifier (after)
   // CHECK-NOT:                       Or
@@ -192,12 +192,12 @@
 
   // CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
-  // CHECK-DAG:     <<Or:j\d+>>        Or [ <<Arg>> <<Arg>> ]
-  // CHECK-DAG:                        Return [ <<Or>> ]
+  // CHECK-DAG:     <<Or:j\d+>>        Or [<<Arg>>,<<Arg>>]
+  // CHECK-DAG:                        Return [<<Or>>]
 
   // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
-  // CHECK-DAG:                        Return [ <<Arg>> ]
+  // CHECK-DAG:                        Return [<<Arg>>]
 
   // CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
   // CHECK-NOT:                        Or
@@ -209,12 +209,12 @@
   // CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Shl:i\d+>>      Shl [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Shl>> ]
+  // CHECK-DAG:     <<Shl:i\d+>>      Shl [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Shl>>]
 
   // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
   // CHECK-NOT:                       Shl
@@ -226,13 +226,13 @@
   // CHECK-START: int Main.Shl1(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Shl:i\d+>>      Shl [ <<Arg>> <<Const1>> ]
-  // CHECK-DAG:                       Return [ <<Shl>> ]
+  // CHECK-DAG:     <<Shl:i\d+>>      Shl [<<Arg>>,<<Const1>>]
+  // CHECK-DAG:                       Return [<<Shl>>]
 
   // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Arg>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Add>> ]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Arg>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Add>>]
 
   // CHECK-START: int Main.Shl1(int) instruction_simplifier (after)
   // CHECK-NOT:                       Shl
@@ -244,12 +244,12 @@
   // CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Shr:j\d+>>      Shr [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Shr>> ]
+  // CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Shr>>]
 
   // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
   // CHECK-NOT:                       Shr
@@ -261,12 +261,12 @@
   // CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
-  // CHECK-DAG:     <<Sub:j\d+>>      Sub [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
   // CHECK-NOT:                       Sub
@@ -278,13 +278,13 @@
   // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   // CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
   // CHECK-NOT:                       Sub
@@ -296,12 +296,12 @@
   // CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<UShr:j\d+>>     UShr [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<UShr>> ]
+  // CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<UShr>>]
 
   // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
   // CHECK-NOT:                       UShr
@@ -313,12 +313,12 @@
   // CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Xor:i\d+>>      Xor [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Xor>> ]
+  // CHECK-DAG:     <<Xor:i\d+>>      Xor [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Xor>>]
 
   // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
   // CHECK-NOT:                       Xor
@@ -330,13 +330,13 @@
   // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<ConstF:i\d+>>   IntConstant -1
-  // CHECK-DAG:     <<Xor:i\d+>>      Xor [ <<Arg>> <<ConstF>> ]
-  // CHECK-DAG:                       Return [ <<Xor>> ]
+  // CHECK-DAG:     <<Xor:i\d+>>      Xor [<<Arg>>,<<ConstF>>]
+  // CHECK-DAG:                       Return [<<Xor>>]
 
   // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Not:i\d+>>      Not [ <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Not>> ]
+  // CHECK-DAG:     <<Not:i\d+>>      Not [<<Arg>>]
+  // CHECK-DAG:                       Return [<<Not>>]
 
   // CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
   // CHECK-NOT:                       Xor
@@ -355,18 +355,18 @@
   // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Arg2>> ]
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:                       Return [ <<Add>> ]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:                       Return [<<Add>>]
 
   // CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
   // CHECK-NOT:                       Neg
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Arg1>> <<Arg2>> ]
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Add>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Arg1>>,<<Arg2>>]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Add>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   public static int AddNegs1(int arg1, int arg2) {
     return -arg1 + -arg2;
@@ -386,32 +386,32 @@
   // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Arg2>> ]
-  // CHECK-DAG:     <<Add1:i\d+>>     Add [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:     <<Add2:i\d+>>     Add [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Add1>> <<Add2>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
+  // CHECK-DAG:     <<Add1:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:     <<Add2:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Add1>>,<<Add2>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Arg2>> ]
-  // CHECK-DAG:     <<Add1:i\d+>>     Add [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:     <<Add2:i\d+>>     Add [ <<Neg1>> <<Neg2>> ]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
+  // CHECK-DAG:     <<Add1:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:     <<Add2:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
   // CHECK-NOT:                       Neg
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Add1>> <<Add2>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Add1>>,<<Add2>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.AddNegs2(int, int) GVN (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Arg2>> ]
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Add>> <<Add>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Add>>,<<Add>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   public static int AddNegs2(int arg1, int arg2) {
     int temp1 = -arg1;
@@ -431,24 +431,24 @@
   // -------------- Arguments and initial negation operations.
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg1:j\d+>>     Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Neg2:j\d+>>     Neg [ <<Arg2>> ]
+  // CHECK-DAG:     <<Neg1:j\d+>>     Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Neg2:j\d+>>     Neg [<<Arg2>>]
   // CHECK:                           Goto
   // -------------- Loop
   // CHECK:                           SuspendCheck
-  // CHECK:         <<Add:j\d+>>      Add [ <<Neg1>> <<Neg2>> ]
+  // CHECK:         <<Add:j\d+>>      Add [<<Neg1>>,<<Neg2>>]
   // CHECK:                           Goto
 
   // CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
   // -------------- Arguments and initial negation operations.
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg1:j\d+>>     Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Neg2:j\d+>>     Neg [ <<Arg2>> ]
+  // CHECK-DAG:     <<Neg1:j\d+>>     Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Neg2:j\d+>>     Neg [<<Arg2>>]
   // CHECK:                           Goto
   // -------------- Loop
   // CHECK:                           SuspendCheck
-  // CHECK:         <<Add:j\d+>>      Add [ <<Neg1>> <<Neg2>> ]
+  // CHECK:         <<Add:j\d+>>      Add [<<Neg1>>,<<Neg2>>]
   // CHECK-NOT:                       Neg
   // CHECK:                           Goto
 
@@ -471,15 +471,15 @@
   // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:j\d+>>      Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Add:j\d+>>      Add [ <<Neg>> <<Arg2>> ]
-  // CHECK-DAG:                       Return [ <<Add>> ]
+  // CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Add:j\d+>>      Add [<<Neg>>,<<Arg2>>]
+  // CHECK-DAG:                       Return [<<Add>>]
 
   // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Sub:j\d+>>      Sub [ <<Arg2>> <<Arg1>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Arg2>>,<<Arg1>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
   // CHECK-NOT:                       Neg
@@ -501,20 +501,20 @@
   // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:j\d+>>      Neg [ <<Arg2>> ]
-  // CHECK-DAG:     <<Add1:j\d+>>     Add [ <<Arg1>> <<Neg>> ]
-  // CHECK-DAG:     <<Add2:j\d+>>     Add [ <<Arg1>> <<Neg>> ]
-  // CHECK-DAG:     <<Res:j\d+>>      Or [ <<Add1>> <<Add2>> ]
-  // CHECK-DAG:                       Return [ <<Res>> ]
+  // CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg2>>]
+  // CHECK-DAG:     <<Add1:j\d+>>     Add [<<Arg1>>,<<Neg>>]
+  // CHECK-DAG:     <<Add2:j\d+>>     Add [<<Arg1>>,<<Neg>>]
+  // CHECK-DAG:     <<Res:j\d+>>      Or [<<Add1>>,<<Add2>>]
+  // CHECK-DAG:                       Return [<<Res>>]
 
   // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:j\d+>>      Neg [ <<Arg2>> ]
-  // CHECK-DAG:     <<Add1:j\d+>>     Add [ <<Arg1>> <<Neg>> ]
-  // CHECK-DAG:     <<Add2:j\d+>>     Add [ <<Arg1>> <<Neg>> ]
-  // CHECK-DAG:     <<Res:j\d+>>      Or [ <<Add1>> <<Add2>> ]
-  // CHECK-DAG:                       Return [ <<Res>> ]
+  // CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg2>>]
+  // CHECK-DAG:     <<Add1:j\d+>>     Add [<<Arg1>>,<<Neg>>]
+  // CHECK-DAG:     <<Add2:j\d+>>     Add [<<Arg1>>,<<Neg>>]
+  // CHECK-DAG:     <<Res:j\d+>>      Or [<<Add1>>,<<Add2>>]
+  // CHECK-DAG:                       Return [<<Res>>]
 
   // CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
   // CHECK-NOT:                       Sub
@@ -531,13 +531,13 @@
 
   // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:     <<Neg1:j\d+>>     Neg [ <<Arg>> ]
-  // CHECK-DAG:     <<Neg2:j\d+>>     Neg [ <<Neg1>> ]
-  // CHECK-DAG:                       Return [ <<Neg2>> ]
+  // CHECK-DAG:     <<Neg1:j\d+>>     Neg [<<Arg>>]
+  // CHECK-DAG:     <<Neg2:j\d+>>     Neg [<<Neg1>>]
+  // CHECK-DAG:                       Return [<<Neg2>>]
 
   // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
   // CHECK-NOT:                       Neg
@@ -555,15 +555,15 @@
 
   // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Arg>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Neg1>> ]
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:                       Return [ <<Add>> ]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Neg1>>]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:                       Return [<<Add>>]
 
   // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Arg>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
   // CHECK-NOT:                       Neg
@@ -573,7 +573,7 @@
   // CHECK:         <<Const0:i\d+>>   IntConstant 0
   // CHECK-NOT:                       Neg
   // CHECK-NOT:                       Add
-  // CHECK:                           Return [ <<Const0>> ]
+  // CHECK:                           Return [<<Const0>>]
 
   public static int NegNeg2(int arg) {
     int temp = -arg;
@@ -590,13 +590,13 @@
   // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
-  // CHECK-DAG:     <<Neg:j\d+>>      Neg [ <<Arg>> ]
-  // CHECK-DAG:     <<Sub:j\d+>>      Sub [ <<Const0>> <<Neg>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg>>]
+  // CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Const0>>,<<Neg>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
   // CHECK-NOT:                       Neg
@@ -615,15 +615,15 @@
   // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Arg1>> <<Arg2>> ]
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Sub>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg1>>,<<Arg2>>]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Sub>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Arg2>> <<Arg1>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg2>>,<<Arg1>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
   // CHECK-NOT:                       Neg
@@ -645,20 +645,20 @@
   // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Arg1>> <<Arg2>> ]
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Sub>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Sub>> ]
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg1>>,<<Arg2>>]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Sub>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Sub>>]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Arg1>> <<Arg2>> ]
-  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [ <<Sub>> ]
-  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [ <<Sub>> ]
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Neg1>> <<Neg2>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg1>>,<<Arg2>>]
+  // CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Sub>>]
+  // CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Sub>>]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Neg1>>,<<Neg2>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   public static int NegSub2(int arg1, int arg2) {
     int temp = arg1 - arg2;
@@ -673,13 +673,13 @@
   // CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
   // CHECK-DAG:     <<ConstF1:j\d+>>  LongConstant -1
-  // CHECK-DAG:     <<Xor1:j\d+>>     Xor [ <<Arg>> <<ConstF1>> ]
-  // CHECK-DAG:     <<Xor2:j\d+>>     Xor [ <<Xor1>> <<ConstF1>> ]
-  // CHECK-DAG:                       Return [ <<Xor2>> ]
+  // CHECK-DAG:     <<Xor1:j\d+>>     Xor [<<Arg>>,<<ConstF1>>]
+  // CHECK-DAG:     <<Xor2:j\d+>>     Xor [<<Xor1>>,<<ConstF1>>]
+  // CHECK-DAG:                       Return [<<Xor2>>]
 
   // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
-  // CHECK-DAG:                       Return [ <<Arg>> ]
+  // CHECK-DAG:                       Return [<<Arg>>]
 
   // CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
   // CHECK-NOT:                       Xor
@@ -691,16 +691,16 @@
   // CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
   // CHECK-DAG:     <<ConstF1:i\d+>>  IntConstant -1
-  // CHECK-DAG:     <<Xor1:i\d+>>     Xor [ <<Arg>> <<ConstF1>> ]
-  // CHECK-DAG:     <<Xor2:i\d+>>     Xor [ <<Xor1>> <<ConstF1>> ]
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Xor1>> <<Xor2>> ]
-  // CHECK-DAG:                       Return [ <<Add>> ]
+  // CHECK-DAG:     <<Xor1:i\d+>>     Xor [<<Arg>>,<<ConstF1>>]
+  // CHECK-DAG:     <<Xor2:i\d+>>     Xor [<<Xor1>>,<<ConstF1>>]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Xor1>>,<<Xor2>>]
+  // CHECK-DAG:                       Return [<<Add>>]
 
   // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
-  // CHECK-DAG:     <<Not:i\d+>>      Not [ <<Arg>> ]
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Not>> <<Arg>> ]
-  // CHECK-DAG:                       Return [ <<Add>> ]
+  // CHECK-DAG:     <<Not:i\d+>>      Not [<<Arg>>]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Not>>,<<Arg>>]
+  // CHECK-DAG:                       Return [<<Add>>]
 
   // CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
   // CHECK-NOT:                       Xor
@@ -718,16 +718,16 @@
   // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Sub:i\d+>>      Sub [ <<Neg>> <<Arg2>> ]
-  // CHECK-DAG:                       Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Neg>>,<<Arg2>>]
+  // CHECK-DAG:                       Return [<<Sub>>]
 
   // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Add:i\d+>>      Add [ <<Arg1>> <<Arg2>> ]
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Add>> ]
-  // CHECK-DAG:                       Return [ <<Neg>> ]
+  // CHECK-DAG:     <<Add:i\d+>>      Add [<<Arg1>>,<<Arg2>>]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Add>>]
+  // CHECK-DAG:                       Return [<<Neg>>]
 
   // CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
   // CHECK-NOT:                       Sub
@@ -749,20 +749,20 @@
   // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Sub1:i\d+>>     Sub [ <<Neg>> <<Arg2>> ]
-  // CHECK-DAG:     <<Sub2:i\d+>>     Sub [ <<Neg>> <<Arg2>> ]
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Sub1>> <<Sub2>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Sub1:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
+  // CHECK-DAG:     <<Sub2:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Sub1>>,<<Sub2>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:i\d+>>      Neg [ <<Arg1>> ]
-  // CHECK-DAG:     <<Sub1:i\d+>>     Sub [ <<Neg>> <<Arg2>> ]
-  // CHECK-DAG:     <<Sub2:i\d+>>     Sub [ <<Neg>> <<Arg2>> ]
-  // CHECK-DAG:     <<Or:i\d+>>       Or [ <<Sub1>> <<Sub2>> ]
-  // CHECK-DAG:                       Return [ <<Or>> ]
+  // CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg1>>]
+  // CHECK-DAG:     <<Sub1:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
+  // CHECK-DAG:     <<Sub2:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
+  // CHECK-DAG:     <<Or:i\d+>>       Or [<<Sub1>>,<<Sub2>>]
+  // CHECK-DAG:                       Return [<<Or>>]
 
   // CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
   // CHECK-NOT:                       Add
@@ -783,22 +783,22 @@
   // -------------- Arguments and initial negation operation.
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:j\d+>>      Neg [ <<Arg1>> ]
+  // CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg1>>]
   // CHECK:                           Goto
   // -------------- Loop
   // CHECK:                           SuspendCheck
-  // CHECK:         <<Sub:j\d+>>      Sub [ <<Neg>> <<Arg2>> ]
+  // CHECK:         <<Sub:j\d+>>      Sub [<<Neg>>,<<Arg2>>]
   // CHECK:                           Goto
 
   // CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
   // -------------- Arguments and initial negation operation.
   // CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
   // CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
-  // CHECK-DAG:     <<Neg:j\d+>>      Neg [ <<Arg1>> ]
+  // CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg1>>]
   // CHECK-DAG:                       Goto
   // -------------- Loop
   // CHECK:                           SuspendCheck
-  // CHECK:         <<Sub:j\d+>>      Sub [ <<Neg>> <<Arg2>> ]
+  // CHECK:         <<Sub:j\d+>>      Sub [<<Neg>>,<<Arg2>>]
   // CHECK-NOT:                       Neg
   // CHECK:                           Goto
 
@@ -814,12 +814,12 @@
   // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     Equal [ <<Arg>> <<Const1>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     Equal [<<Arg>>,<<Const1>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.EqualTrueRhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:                       If [ <<Arg>> ]
+  // CHECK-DAG:                       If [<<Arg>>]
 
   public static int EqualTrueRhs(boolean arg) {
     return (arg != true) ? 3 : 5;
@@ -828,12 +828,12 @@
   // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     Equal [ <<Const1>> <<Arg>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     Equal [<<Const1>>,<<Arg>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.EqualTrueLhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:                       If [ <<Arg>> ]
+  // CHECK-DAG:                       If [<<Arg>>]
 
   public static int EqualTrueLhs(boolean arg) {
     return (true != arg) ? 3 : 5;
@@ -842,13 +842,13 @@
   // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Cond:z\d+>>     Equal [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     Equal [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.EqualFalseRhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [ <<Arg>> ]
-  // CHECK-DAG:                       If [ <<NotArg>> ]
+  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [<<Arg>>]
+  // CHECK-DAG:                       If [<<NotArg>>]
 
   public static int EqualFalseRhs(boolean arg) {
     return (arg != false) ? 3 : 5;
@@ -857,13 +857,13 @@
   // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Cond:z\d+>>     Equal [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     Equal [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.EqualFalseLhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [ <<Arg>> ]
-  // CHECK-DAG:                       If [ <<NotArg>> ]
+  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [<<Arg>>]
+  // CHECK-DAG:                       If [<<NotArg>>]
 
   public static int EqualFalseLhs(boolean arg) {
     return (false != arg) ? 3 : 5;
@@ -872,13 +872,13 @@
   // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [ <<Arg>> <<Const1>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<Arg>>,<<Const1>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.NotEqualTrueRhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [ <<Arg>> ]
-  // CHECK-DAG:                       If [ <<NotArg>> ]
+  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [<<Arg>>]
+  // CHECK-DAG:                       If [<<NotArg>>]
 
   public static int NotEqualTrueRhs(boolean arg) {
     return (arg == true) ? 3 : 5;
@@ -887,13 +887,13 @@
   // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [ <<Const1>> <<Arg>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<Const1>>,<<Arg>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.NotEqualTrueLhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [ <<Arg>> ]
-  // CHECK-DAG:                       If [ <<NotArg>> ]
+  // CHECK-DAG:     <<NotArg:z\d+>>   BooleanNot [<<Arg>>]
+  // CHECK-DAG:                       If [<<NotArg>>]
 
   public static int NotEqualTrueLhs(boolean arg) {
     return (true == arg) ? 3 : 5;
@@ -902,12 +902,12 @@
   // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [ <<Arg>> <<Const0>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<Arg>>,<<Const0>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.NotEqualFalseRhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:                       If [ <<Arg>> ]
+  // CHECK-DAG:                       If [<<Arg>>]
 
   public static int NotEqualFalseRhs(boolean arg) {
     return (arg == false) ? 3 : 5;
@@ -916,12 +916,12 @@
   // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (before)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [ <<Const0>> <<Arg>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<Const0>>,<<Arg>>]
+  // CHECK-DAG:                       If [<<Cond>>]
 
   // CHECK-START: int Main.NotEqualFalseLhs(boolean) instruction_simplifier (after)
   // CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
-  // CHECK-DAG:                       If [ <<Arg>> ]
+  // CHECK-DAG:                       If [<<Arg>>]
 
   public static int NotEqualFalseLhs(boolean arg) {
     return (false == arg) ? 3 : 5;
@@ -935,14 +935,14 @@
 
   // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (before)
   // CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
-  // CHECK-DAG:     <<NotArg:z\d+>>    BooleanNot [ <<Arg>> ]
-  // CHECK-DAG:     <<NotNotArg:z\d+>> BooleanNot [ <<NotArg>> ]
-  // CHECK-DAG:                        Return [ <<NotNotArg>> ]
+  // CHECK-DAG:     <<NotArg:z\d+>>    BooleanNot [<<Arg>>]
+  // CHECK-DAG:     <<NotNotArg:z\d+>> BooleanNot [<<NotArg>>]
+  // CHECK-DAG:                        Return [<<NotNotArg>>]
 
   // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
   // CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
-  // CHECK-DAG:                        BooleanNot [ <<Arg>> ]
-  // CHECK-DAG:                        Return [ <<Arg>> ]
+  // CHECK-DAG:                        BooleanNot [<<Arg>>]
+  // CHECK-DAG:                        Return [<<Arg>>]
 
   // CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_types (after)
   // CHECK:                            BooleanNot
@@ -959,14 +959,14 @@
   // CHECK-START: float Main.Div2(float) instruction_simplifier (before)
   // CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
   // CHECK-DAG:      <<Const2:f\d+>>   FloatConstant 2
-  // CHECK-DAG:      <<Div:f\d+>>      Div [ <<Arg>> <<Const2>> ]
-  // CHECK-DAG:                        Return [ <<Div>> ]
+  // CHECK-DAG:      <<Div:f\d+>>      Div [<<Arg>>,<<Const2>>]
+  // CHECK-DAG:                        Return [<<Div>>]
 
   // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
   // CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
   // CHECK-DAG:      <<ConstP5:f\d+>>  FloatConstant 0.5
-  // CHECK-DAG:      <<Mul:f\d+>>      Mul [ <<Arg>> <<ConstP5>> ]
-  // CHECK-DAG:                        Return [ <<Mul>> ]
+  // CHECK-DAG:      <<Mul:f\d+>>      Mul [<<Arg>>,<<ConstP5>>]
+  // CHECK-DAG:                        Return [<<Mul>>]
 
   // CHECK-START: float Main.Div2(float) instruction_simplifier (after)
   // CHECK-NOT:                        Div
@@ -978,14 +978,14 @@
   // CHECK-START: double Main.Div2(double) instruction_simplifier (before)
   // CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
   // CHECK-DAG:      <<Const2:d\d+>>   DoubleConstant 2
-  // CHECK-DAG:      <<Div:d\d+>>      Div [ <<Arg>> <<Const2>> ]
-  // CHECK-DAG:                        Return [ <<Div>> ]
+  // CHECK-DAG:      <<Div:d\d+>>      Div [<<Arg>>,<<Const2>>]
+  // CHECK-DAG:                        Return [<<Div>>]
 
   // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
   // CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
   // CHECK-DAG:      <<ConstP5:d\d+>>  DoubleConstant 0.5
-  // CHECK-DAG:      <<Mul:d\d+>>      Mul [ <<Arg>> <<ConstP5>> ]
-  // CHECK-DAG:                        Return [ <<Mul>> ]
+  // CHECK-DAG:      <<Mul:d\d+>>      Mul [<<Arg>>,<<ConstP5>>]
+  // CHECK-DAG:                        Return [<<Mul>>]
 
   // CHECK-START: double Main.Div2(double) instruction_simplifier (after)
   // CHECK-NOT:                        Div
@@ -996,14 +996,14 @@
   // CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
   // CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
   // CHECK-DAG:      <<ConstMP25:f\d+>>   FloatConstant -0.25
-  // CHECK-DAG:      <<Div:f\d+>>      Div [ <<Arg>> <<ConstMP25>> ]
-  // CHECK-DAG:                        Return [ <<Div>> ]
+  // CHECK-DAG:      <<Div:f\d+>>      Div [<<Arg>>,<<ConstMP25>>]
+  // CHECK-DAG:                        Return [<<Div>>]
 
   // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
   // CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
   // CHECK-DAG:      <<ConstM4:f\d+>>  FloatConstant -4
-  // CHECK-DAG:      <<Mul:f\d+>>      Mul [ <<Arg>> <<ConstM4>> ]
-  // CHECK-DAG:                        Return [ <<Mul>> ]
+  // CHECK-DAG:      <<Mul:f\d+>>      Mul [<<Arg>>,<<ConstM4>>]
+  // CHECK-DAG:                        Return [<<Mul>>]
 
   // CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
   // CHECK-NOT:                        Div
@@ -1015,14 +1015,14 @@
   // CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
   // CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
   // CHECK-DAG:      <<ConstMP25:d\d+>>   DoubleConstant -0.25
-  // CHECK-DAG:      <<Div:d\d+>>      Div [ <<Arg>> <<ConstMP25>> ]
-  // CHECK-DAG:                        Return [ <<Div>> ]
+  // CHECK-DAG:      <<Div:d\d+>>      Div [<<Arg>>,<<ConstMP25>>]
+  // CHECK-DAG:                        Return [<<Div>>]
 
   // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
   // CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
   // CHECK-DAG:      <<ConstM4:d\d+>>  DoubleConstant -4
-  // CHECK-DAG:      <<Mul:d\d+>>      Mul [ <<Arg>> <<ConstM4>> ]
-  // CHECK-DAG:                        Return [ <<Mul>> ]
+  // CHECK-DAG:      <<Mul:d\d+>>      Mul [<<Arg>>,<<ConstM4>>]
+  // CHECK-DAG:                        Return [<<Mul>>]
 
   // CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
   // CHECK-NOT:                        Div
diff --git a/test/462-checker-inlining-across-dex-files/src/Main.java b/test/462-checker-inlining-across-dex-files/src/Main.java
index 5ebf3d1..3d583b4 100644
--- a/test/462-checker-inlining-across-dex-files/src/Main.java
+++ b/test/462-checker-inlining-across-dex-files/src/Main.java
@@ -34,14 +34,14 @@
 
   // CHECK-START: int Main.inlineReturnIntMethod() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: int Main.inlineReturnIntMethod() inliner (after)
   // CHECK-DAG:     <<Const38:i\d+>> IntConstant 38
-  // CHECK-DAG:                      Return [ <<Const38>> ]
+  // CHECK-DAG:                      Return [<<Const38>>]
 
   public static int inlineReturnIntMethod() {
     return OtherDex.returnIntMethod();
@@ -49,11 +49,11 @@
 
   // CHECK-START: int Main.dontInlineOtherDexStatic() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.dontInlineOtherDexStatic() inliner (after)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   public static int dontInlineOtherDexStatic() {
     return OtherDex.returnOtherDexStatic();
@@ -61,14 +61,14 @@
 
   // CHECK-START: int Main.inlineMainStatic() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.inlineMainStatic() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: int Main.inlineMainStatic() inliner (after)
   // CHECK-DAG:     <<Static:i\d+>>  StaticFieldGet
-  // CHECK-DAG:                      Return [ <<Static>> ]
+  // CHECK-DAG:                      Return [<<Static>>]
 
   public static int inlineMainStatic() {
     return OtherDex.returnMainStatic();
@@ -76,11 +76,11 @@
 
   // CHECK-START: int Main.dontInlineRecursiveCall() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.dontInlineRecursiveCall() inliner (after)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   public static int dontInlineRecursiveCall() {
     return OtherDex.recursiveCall();
@@ -88,11 +88,11 @@
 
   // CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (before)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: java.lang.String Main.dontInlineReturnString() inliner (after)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   public static String dontInlineReturnString() {
     return OtherDex.returnString();
@@ -100,11 +100,11 @@
 
   // CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (before)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: java.lang.Class Main.dontInlineOtherDexClass() inliner (after)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   public static Class dontInlineOtherDexClass() {
     return OtherDex.returnOtherDexClass();
@@ -112,14 +112,15 @@
 
   // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (before)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: java.lang.Class Main.inlineMainClass() inliner (after)
-  // CHECK-DAG:     <<Class:l\d+>>  LoadClass
-  // CHECK-DAG:                     Return [ <<Class>> ]
+  // CHECK-DAG:                     Return [<<Class:l\d+>>]
+  // CHECK-DAG:     <<Class>>       LoadClass
+  // Note: Verify backwards because there are two LoadClass instructions
 
   public static Class inlineMainClass() {
     return OtherDex.returnMainClass();
@@ -127,11 +128,11 @@
 
   // CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (before)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: java.lang.Class Main.dontInlineOtherDexClassStaticCall() inliner (after)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   public static Class dontInlineOtherDexClassStaticCall() {
     return OtherDex.returnOtherDexClassStaticCall();
@@ -139,14 +140,15 @@
 
   // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (before)
   // CHECK-DAG:     <<Invoke:l\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: java.lang.Class Main.inlineOtherDexCallingMain() inliner (after)
-  // CHECK-DAG:     <<Class:l\d+>>  LoadClass
-  // CHECK-DAG:                     Return [ <<Class>> ]
+  // CHECK-DAG:                     Return [<<Class:l\d+>>]
+  // CHECK-DAG:     <<Class>>       LoadClass
+  // Note: Verify backwards because there are two LoadClass instructions
 
   public static Class inlineOtherDexCallingMain() {
     return OtherDex.returnOtherDexCallingMain();
diff --git a/test/463-checker-boolean-simplifier/src/Main.java b/test/463-checker-boolean-simplifier/src/Main.java
index 3f3110f..e237448 100644
--- a/test/463-checker-boolean-simplifier/src/Main.java
+++ b/test/463-checker-boolean-simplifier/src/Main.java
@@ -41,9 +41,9 @@
   // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:                       If [ <<Param>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>      Phi [ <<Const1>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Phi>> ]
+  // CHECK-DAG:                       If [<<Param>>]
+  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const1>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Phi>>]
 
   // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (before)
   // CHECK:                           Goto
@@ -54,8 +54,8 @@
   // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
   // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
-  // CHECK-DAG:     <<NotParam:z\d+>> BooleanNot [ <<Param>> ]
-  // CHECK-DAG:                       Return [ <<NotParam>> ]
+  // CHECK-DAG:     <<NotParam:z\d+>> BooleanNot [<<Param>>]
+  // CHECK-DAG:                       Return [<<NotParam>>]
 
   // CHECK-START: boolean Main.BooleanNot(boolean) boolean_simplifier (after)
   // CHECK-NOT:                       If
@@ -79,18 +79,18 @@
   // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThan [ <<ParamX>> <<ParamY>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>      Phi [ <<Const0>> <<Const1>> ]
-  // CHECK-DAG:                       Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThan [<<ParamX>>,<<ParamY>>]
+  // CHECK-DAG:                       If [<<Cond>>]
+  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const0>>,<<Const1>>]
+  // CHECK-DAG:                       Return [<<Phi>>]
 
   // CHECK-START: boolean Main.GreaterThan(int, int) boolean_simplifier (after)
   // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
   // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThan [ <<ParamX>> <<ParamY>> ]
-  // CHECK-DAG:                       Return [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThan [<<ParamX>>,<<ParamY>>]
+  // CHECK-DAG:                       Return [<<Cond>>]
 
   public static boolean GreaterThan(int x, int y) {
     return (x <= y) ? false : true;
@@ -106,18 +106,18 @@
   // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThanOrEqual [ <<ParamX>> <<ParamY>> ]
-  // CHECK-DAG:                       If [ <<Cond>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>      Phi [ <<Const1>> <<Const0>> ]
-  // CHECK-DAG:                       Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     GreaterThanOrEqual [<<ParamX>>,<<ParamY>>]
+  // CHECK-DAG:                       If [<<Cond>>]
+  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const1>>,<<Const0>>]
+  // CHECK-DAG:                       Return [<<Phi>>]
 
   // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
   // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
   // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<Cond:z\d+>>     LessThan [ <<ParamX>> <<ParamY>> ]
-  // CHECK-DAG:                       Return [ <<Cond>> ]
+  // CHECK-DAG:     <<Cond:z\d+>>     LessThan [<<ParamX>>,<<ParamY>>]
+  // CHECK-DAG:                       Return [<<Cond>>]
 
   // CHECK-START: boolean Main.LessThan(int, int) boolean_simplifier (after)
   // CHECK-NOT:                       GreaterThanOrEqual
@@ -137,25 +137,25 @@
   // CHECK-DAG:     <<ParamZ:i\d+>>   ParameterValue
   // CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   // CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
-  // CHECK-DAG:     <<CondXY:z\d+>>   GreaterThan [ <<ParamX>> <<ParamY>> ]
-  // CHECK-DAG:                       If [ <<CondXY>> ]
-  // CHECK-DAG:     <<CondYZ:z\d+>>   GreaterThan [ <<ParamY>> <<ParamZ>> ]
-  // CHECK-DAG:                       If [ <<CondYZ>> ]
-  // CHECK-DAG:     <<CondXYZ:z\d+>>  NotEqual [ <<PhiXY:i\d+>> <<PhiYZ:i\d+>> ]
-  // CHECK-DAG:                       If [ <<CondXYZ>> ]
-  // CHECK-DAG:                       Return [ <<PhiXYZ:i\d+>> ]
-  // CHECK-DAG:     <<PhiXY>>         Phi [ <<Const1>> <<Const0>> ]
-  // CHECK-DAG:     <<PhiYZ>>         Phi [ <<Const1>> <<Const0>> ]
-  // CHECK-DAG:     <<PhiXYZ>>        Phi [ <<Const1>> <<Const0>> ]
+  // CHECK-DAG:     <<CondXY:z\d+>>   GreaterThan [<<ParamX>>,<<ParamY>>]
+  // CHECK-DAG:                       If [<<CondXY>>]
+  // CHECK-DAG:     <<CondYZ:z\d+>>   GreaterThan [<<ParamY>>,<<ParamZ>>]
+  // CHECK-DAG:                       If [<<CondYZ>>]
+  // CHECK-DAG:     <<CondXYZ:z\d+>>  NotEqual [<<PhiXY:i\d+>>,<<PhiYZ:i\d+>>]
+  // CHECK-DAG:                       If [<<CondXYZ>>]
+  // CHECK-DAG:                       Return [<<PhiXYZ:i\d+>>]
+  // CHECK-DAG:     <<PhiXY>>         Phi [<<Const1>>,<<Const0>>]
+  // CHECK-DAG:     <<PhiYZ>>         Phi [<<Const1>>,<<Const0>>]
+  // CHECK-DAG:     <<PhiXYZ>>        Phi [<<Const1>>,<<Const0>>]
 
   // CHECK-START: boolean Main.ValuesOrdered(int, int, int) boolean_simplifier (after)
   // CHECK-DAG:     <<ParamX:i\d+>>   ParameterValue
   // CHECK-DAG:     <<ParamY:i\d+>>   ParameterValue
   // CHECK-DAG:     <<ParamZ:i\d+>>   ParameterValue
-  // CHECK-DAG:     <<CmpXY:z\d+>>    LessThanOrEqual [ <<ParamX>> <<ParamY>> ]
-  // CHECK-DAG:     <<CmpYZ:z\d+>>    LessThanOrEqual [ <<ParamY>> <<ParamZ>> ]
-  // CHECK-DAG:     <<CmpXYZ:z\d+>>   Equal [ <<CmpXY>> <<CmpYZ>> ]
-  // CHECK-DAG:                       Return [ <<CmpXYZ>> ]
+  // CHECK-DAG:     <<CmpXY:z\d+>>    LessThanOrEqual [<<ParamX>>,<<ParamY>>]
+  // CHECK-DAG:     <<CmpYZ:z\d+>>    LessThanOrEqual [<<ParamY>>,<<ParamZ>>]
+  // CHECK-DAG:     <<CmpXYZ:z\d+>>   Equal [<<CmpXY>>,<<CmpYZ>>]
+  // CHECK-DAG:                       Return [<<CmpXYZ>>]
 
   public static boolean ValuesOrdered(int x, int y, int z) {
     return (x <= y) == (y <= z);
@@ -165,18 +165,18 @@
   // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
   // CHECK-DAG:     <<Const42:i\d+>>  IntConstant 42
   // CHECK-DAG:     <<Const43:i\d+>>  IntConstant 43
-  // CHECK-DAG:     <<NotParam:z\d+>> BooleanNot [ <<Param>> ]
-  // CHECK-DAG:                       If [ <<NotParam>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>      Phi [ <<Const42>> <<Const43>> ]
-  // CHECK-DAG:                       Return [ <<Phi>> ]
+  // CHECK-DAG:     <<NotParam:z\d+>> BooleanNot [<<Param>>]
+  // CHECK-DAG:                       If [<<NotParam>>]
+  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const42>>,<<Const43>>]
+  // CHECK-DAG:                       Return [<<Phi>>]
 
   // CHECK-START: int Main.NegatedCondition(boolean) boolean_simplifier (after)
   // CHECK-DAG:     <<Param:z\d+>>    ParameterValue
   // CHECK-DAG:     <<Const42:i\d+>>  IntConstant 42
   // CHECK-DAG:     <<Const43:i\d+>>  IntConstant 43
-  // CHECK-DAG:                       If [ <<Param>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>      Phi [ <<Const42>> <<Const43>> ]
-  // CHECK-DAG:                       Return [ <<Phi>> ]
+  // CHECK-DAG:                       If [<<Param>>]
+  // CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const42>>,<<Const43>>]
+  // CHECK-DAG:                       Return [<<Phi>>]
 
   // Note: The fact that branches are swapped is verified by running the test.
 
diff --git a/test/464-checker-inline-sharpen-calls/src/Main.java b/test/464-checker-inline-sharpen-calls/src/Main.java
index 626823e..e451f70 100644
--- a/test/464-checker-inline-sharpen-calls/src/Main.java
+++ b/test/464-checker-inline-sharpen-calls/src/Main.java
@@ -32,14 +32,14 @@
 
   // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (before)
   // CHECK-DAG:     <<Invoke:i\d+>>  InvokeStaticOrDirect
-  // CHECK-DAG:                      Return [ <<Invoke>> ]
+  // CHECK-DAG:                      Return [<<Invoke>>]
 
   // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
   // CHECK-NOT:                      InvokeStaticOrDirect
 
   // CHECK-START: int Main.inlineSharpenStringInvoke() inliner (after)
   // CHECK-DAG:     <<Field:i\d+>>   InstanceFieldGet
-  // CHECK-DAG:                      Return [ <<Field>> ]
+  // CHECK-DAG:                      Return [<<Field>>]
 
   public static int inlineSharpenStringInvoke() {
     return "Foo".length();
diff --git a/test/465-checker-clinit-gvn/src/Main.java b/test/465-checker-clinit-gvn/src/Main.java
index b712715..ac2863c 100644
--- a/test/465-checker-clinit-gvn/src/Main.java
+++ b/test/465-checker-clinit-gvn/src/Main.java
@@ -28,13 +28,13 @@
 
   // CHECK-START: int Main.accessTwoStatics() GVN (before)
   // CHECK-DAG:     <<Class1:l\d+>>  LoadClass
-  // CHECK-DAG:                      ClinitCheck [ <<Class1>> ]
+  // CHECK-DAG:                      ClinitCheck [<<Class1>>]
   // CHECK-DAG:     <<Class2:l\d+>>  LoadClass
-  // CHECK-DAG:                      ClinitCheck [ <<Class2>> ]
+  // CHECK-DAG:                      ClinitCheck [<<Class2>>]
 
   // CHECK-START: int Main.accessTwoStatics() GVN (after)
   // CHECK-DAG:     <<Class:l\d+>>   LoadClass
-  // CHECK-DAG:                      ClinitCheck [ <<Class>> ]
+  // CHECK-DAG:                      ClinitCheck [<<Class>>]
   // CHECK-NOT:                      ClinitCheck
 
   public static int accessTwoStatics() {
@@ -43,13 +43,13 @@
 
   // CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (before)
   // CHECK-DAG:     <<Class1:l\d+>>  LoadClass
-  // CHECK-DAG:                      ClinitCheck [ <<Class1>> ]
+  // CHECK-DAG:                      ClinitCheck [<<Class1>>]
   // CHECK-DAG:     <<Class2:l\d+>>  LoadClass
-  // CHECK-DAG:                      ClinitCheck [ <<Class2>> ]
+  // CHECK-DAG:                      ClinitCheck [<<Class2>>]
 
   // CHECK-START: int Main.accessTwoStaticsCallInBetween() GVN (after)
   // CHECK-DAG:     <<Class:l\d+>>   LoadClass
-  // CHECK-DAG:                      ClinitCheck [ <<Class>> ]
+  // CHECK-DAG:                      ClinitCheck [<<Class>>]
   // CHECK-NOT:                      ClinitCheck
 
   public static int accessTwoStaticsCallInBetween() {
diff --git a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
index 0cb5313..33e6dc3 100644
--- a/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
+++ b/test/468-checker-bool-simplifier-regression/smali/TestCase.smali
@@ -22,14 +22,14 @@
 # CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
 # CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
 # CHECK-DAG:     <<Value:z\d+>>    StaticFieldGet
-# CHECK-DAG:                       If [ <<Value>> ]
-# CHECK-DAG:     <<Phi:i\d+>>      Phi [ <<Const1>> <<Const0>> ]
-# CHECK-DAG:                       Return [ <<Phi>> ]
+# CHECK-DAG:                       If [<<Value>>]
+# CHECK-DAG:     <<Phi:i\d+>>      Phi [<<Const1>>,<<Const0>>]
+# CHECK-DAG:                       Return [<<Phi>>]
 
 # CHECK-START: boolean TestCase.testCase() boolean_simplifier (after)
 # CHECK-DAG:     <<Value:z\d+>>    StaticFieldGet
-# CHECK-DAG:     <<Not:z\d+>>      BooleanNot [ <<Value>> ]
-# CHECK-DAG:                       Return [ <<Not>> ]
+# CHECK-DAG:     <<Not:z\d+>>      BooleanNot [<<Value>>]
+# CHECK-DAG:                       Return [<<Not>>]
 
 .method public static testCase()Z
     .registers 2
diff --git a/test/474-checker-boolean-input/src/Main.java b/test/474-checker-boolean-input/src/Main.java
index a395ff9..490f7f9 100644
--- a/test/474-checker-boolean-input/src/Main.java
+++ b/test/474-checker-boolean-input/src/Main.java
@@ -29,7 +29,7 @@
 
   // CHECK-START: boolean Main.TestPhiAsBoolean(int) boolean_simplifier (after)
   // CHECK-DAG:     <<Phi:i\d+>>     Phi
-  // CHECK-DAG:                      BooleanNot [ <<Phi>> ]
+  // CHECK-DAG:                      BooleanNot [<<Phi>>]
 
   public static boolean f1;
   public static boolean f2;
@@ -49,7 +49,7 @@
 
   // CHECK-START: boolean Main.TestAndAsBoolean(boolean, boolean) boolean_simplifier (after)
   // CHECK-DAG:     <<And:i\d+>>     And
-  // CHECK-DAG:                      BooleanNot [ <<And>> ]
+  // CHECK-DAG:                      BooleanNot [<<And>>]
 
   public static boolean InlineAnd(boolean x, boolean y) {
     return x & y;
@@ -66,7 +66,7 @@
 
   // CHECK-START: boolean Main.TestOrAsBoolean(boolean, boolean) boolean_simplifier (after)
   // CHECK-DAG:     <<Or:i\d+>>      Or
-  // CHECK-DAG:                      BooleanNot [ <<Or>> ]
+  // CHECK-DAG:                      BooleanNot [<<Or>>]
 
   public static boolean InlineOr(boolean x, boolean y) {
     return x | y;
@@ -83,7 +83,7 @@
 
   // CHECK-START: boolean Main.TestXorAsBoolean(boolean, boolean) boolean_simplifier (after)
   // CHECK-DAG:     <<Xor:i\d+>>     Xor
-  // CHECK-DAG:                      BooleanNot [ <<Xor>> ]
+  // CHECK-DAG:                      BooleanNot [<<Xor>>]
 
   public static boolean InlineXor(boolean x, boolean y) {
     return x ^ y;
diff --git a/test/478-checker-clinit-check-pruning/src/Main.java b/test/478-checker-clinit-check-pruning/src/Main.java
index b36b7d6..61199a7 100644
--- a/test/478-checker-clinit-check-pruning/src/Main.java
+++ b/test/478-checker-clinit-check-pruning/src/Main.java
@@ -25,12 +25,12 @@
 
   // CHECK-START: void Main.invokeStaticInlined() builder (after)
   // CHECK-DAG:     <<LoadClass:l\d+>>    LoadClass
-  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [ <<LoadClass>> ]
-  // CHECK-DAG:                           InvokeStaticOrDirect [ <<ClinitCheck>> ]
+  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [<<LoadClass>>]
+  // CHECK-DAG:                           InvokeStaticOrDirect [<<ClinitCheck>>]
 
   // CHECK-START: void Main.invokeStaticInlined() inliner (after)
   // CHECK-DAG:     <<LoadClass:l\d+>>    LoadClass
-  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [ <<LoadClass>> ]
+  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [<<LoadClass>>]
 
   // CHECK-START: void Main.invokeStaticInlined() inliner (after)
   // CHECK-NOT:                           InvokeStaticOrDirect
@@ -68,13 +68,13 @@
 
   // CHECK-START: void Main.invokeStaticNotInlined() builder (after)
   // CHECK-DAG:     <<LoadClass:l\d+>>    LoadClass
-  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [ <<LoadClass>> ]
-  // CHECK-DAG:                           InvokeStaticOrDirect [ <<ClinitCheck>> ]
+  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [<<LoadClass>>]
+  // CHECK-DAG:                           InvokeStaticOrDirect [<<ClinitCheck>>]
 
   // CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
   // CHECK-DAG:     <<LoadClass:l\d+>>    LoadClass
-  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [ <<LoadClass>> ]
-  // CHECK-DAG:                           InvokeStaticOrDirect [ <<ClinitCheck>> ]
+  // CHECK-DAG:     <<ClinitCheck:l\d+>>  ClinitCheck [<<LoadClass>>]
+  // CHECK-DAG:                           InvokeStaticOrDirect [<<ClinitCheck>>]
 
   // The following checks ensure the clinit check and load class
   // instructions added by the builder are pruned by the
diff --git a/test/480-checker-dead-blocks/src/Main.java b/test/480-checker-dead-blocks/src/Main.java
index dda1a43..b76755e 100644
--- a/test/480-checker-dead-blocks/src/Main.java
+++ b/test/480-checker-dead-blocks/src/Main.java
@@ -34,16 +34,16 @@
   // CHECK-DAG:     <<ArgX:i\d+>>    ParameterValue
   // CHECK-DAG:     <<ArgY:i\d+>>    ParameterValue
   // CHECK-DAG:                      If
-  // CHECK-DAG:     <<Add:i\d+>>     Add [ <<ArgX>> <<ArgY>> ]
-  // CHECK-DAG:     <<Sub:i\d+>>     Sub [ <<ArgX>> <<ArgY>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>     Phi [ <<Add>> <<Sub>> ]
-  // CHECK-DAG:                      Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Add:i\d+>>     Add [<<ArgX>>,<<ArgY>>]
+  // CHECK-DAG:     <<Sub:i\d+>>     Sub [<<ArgX>>,<<ArgY>>]
+  // CHECK-DAG:     <<Phi:i\d+>>     Phi [<<Add>>,<<Sub>>]
+  // CHECK-DAG:                      Return [<<Phi>>]
 
   // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
   // CHECK-DAG:     <<ArgX:i\d+>>    ParameterValue
   // CHECK-DAG:     <<ArgY:i\d+>>    ParameterValue
-  // CHECK-DAG:     <<Add:i\d+>>     Add [ <<ArgX>> <<ArgY>> ]
-  // CHECK-DAG:                      Return [ <<Add>> ]
+  // CHECK-DAG:     <<Add:i\d+>>     Add [<<ArgX>>,<<ArgY>>]
+  // CHECK-DAG:                      Return [<<Add>>]
 
   // CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after)
   // CHECK-NOT:                      If
@@ -64,16 +64,16 @@
   // CHECK-DAG:     <<ArgX:i\d+>>    ParameterValue
   // CHECK-DAG:     <<ArgY:i\d+>>    ParameterValue
   // CHECK-DAG:                      If
-  // CHECK-DAG:     <<Add:i\d+>>     Add [ <<ArgX>> <<ArgY>> ]
-  // CHECK-DAG:     <<Sub:i\d+>>     Sub [ <<ArgX>> <<ArgY>> ]
-  // CHECK-DAG:     <<Phi:i\d+>>     Phi [ <<Add>> <<Sub>> ]
-  // CHECK-DAG:                      Return [ <<Phi>> ]
+  // CHECK-DAG:     <<Add:i\d+>>     Add [<<ArgX>>,<<ArgY>>]
+  // CHECK-DAG:     <<Sub:i\d+>>     Sub [<<ArgX>>,<<ArgY>>]
+  // CHECK-DAG:     <<Phi:i\d+>>     Phi [<<Add>>,<<Sub>>]
+  // CHECK-DAG:                      Return [<<Phi>>]
 
   // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
   // CHECK-DAG:     <<ArgX:i\d+>>    ParameterValue
   // CHECK-DAG:     <<ArgY:i\d+>>    ParameterValue
-  // CHECK-DAG:     <<Sub:i\d+>>     Sub [ <<ArgX>> <<ArgY>> ]
-  // CHECK-DAG:                      Return [ <<Sub>> ]
+  // CHECK-DAG:     <<Sub:i\d+>>     Sub [<<ArgX>>,<<ArgY>>]
+  // CHECK-DAG:                      Return [<<Sub>>]
 
   // CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after)
   // CHECK-NOT:                      If
@@ -126,7 +126,7 @@
 
   // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
   // CHECK-DAG:     <<Arg:i\d+>>     ParameterValue
-  // CHECK-DAG:                      Return [ <<Arg>> ]
+  // CHECK-DAG:                      Return [<<Arg>>]
 
   // CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after)
   // CHECK-NOT:                      If
@@ -146,7 +146,7 @@
 
   // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
   // CHECK-DAG:     <<Arg:i\d+>>     ParameterValue
-  // CHECK-DAG:                      Return [ <<Arg>> ]
+  // CHECK-DAG:                      Return [<<Arg>>]
 
   // CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after)
   // CHECK-NOT:                      If
diff --git a/test/482-checker-loop-back-edge-use/src/Main.java b/test/482-checker-loop-back-edge-use/src/Main.java
index 334792e..9e1076a 100644
--- a/test/482-checker-loop-back-edge-use/src/Main.java
+++ b/test/482-checker-loop-back-edge-use/src/Main.java
@@ -18,14 +18,14 @@
 public class Main {
 
   // CHECK-START: void Main.loop1(boolean) liveness (after)
-  // CHECK:         ParameterValue  liveness:2  ranges:[ 2-22 ] uses:[ 17 22 ]
+  // CHECK:         ParameterValue  liveness:2  ranges:[2-22] uses:[17,22]
   // CHECK:         Goto            liveness:20
   public static void loop1(boolean incoming) {
     while (incoming) {}
   }
 
   // CHECK-START: void Main.loop2(boolean) liveness (after)
-  // CHECK:         ParameterValue  liveness:2  ranges:[ 2-42 ] uses:[ 33 38 42 ]
+  // CHECK:         ParameterValue  liveness:2  ranges:[2-42] uses:[33,38,42]
   // CHECK:         Goto            liveness:36
   // CHECK:         Goto            liveness:40
   public static void loop2(boolean incoming) {
@@ -36,7 +36,7 @@
   }
 
   // CHECK-START: void Main.loop3(boolean) liveness (after)
-  // CHECK:         ParameterValue  liveness:2  ranges:[ 2-60 ] uses:[ 56 60 ]
+  // CHECK:         ParameterValue  liveness:2  ranges:[2-60] uses:[56,60]
   // CHECK:         Goto            liveness:58
 
   // CHECK-START: void Main.loop3(boolean) liveness (after)
@@ -50,7 +50,7 @@
   }
 
   // CHECK-START: void Main.loop4(boolean) liveness (after)
-  // CHECK:         ParameterValue  liveness:2  ranges:[ 2-22 ] uses:[ 22 ]
+  // CHECK:         ParameterValue  liveness:2  ranges:[2-22] uses:[22]
 
   // CHECK-START: void Main.loop4(boolean) liveness (after)
   // CHECK-NOT:     Goto            liveness:20
@@ -63,7 +63,7 @@
   }
 
   // CHECK-START: void Main.loop5(boolean) liveness (after)
-  // CHECK:         ParameterValue  liveness:2  ranges:[ 2-50 ] uses:[ 33 42 46 50 ]
+  // CHECK:         ParameterValue  liveness:2  ranges:[2-50] uses:[33,42,46,50]
   // CHECK:         Goto            liveness:44
   // CHECK:         Goto            liveness:48
   public static void loop5(boolean incoming) {
@@ -76,7 +76,7 @@
   }
 
   // CHECK-START: void Main.loop6(boolean) liveness (after)
-  // CHECK          ParameterValue  liveness:2  ranges:[ 2-46 ] uses:[ 24 46 ]
+  // CHECK          ParameterValue  liveness:2  ranges:[2-46] uses:[24,46]
   // CHECK:         Goto            liveness:44
 
   // CHECK-START: void Main.loop6(boolean) liveness (after)
@@ -90,7 +90,7 @@
   }
 
   // CHECK-START: void Main.loop7(boolean) liveness (after)
-  // CHECK:         ParameterValue  liveness:2  ranges:[ 2-50 ] uses:[ 32 41 46 50 ]
+  // CHECK:         ParameterValue  liveness:2  ranges:[2-50] uses:[32,41,46,50]
   // CHECK:         Goto            liveness:44
   // CHECK:         Goto            liveness:48
   public static void loop7(boolean incoming) {
@@ -102,7 +102,7 @@
   }
 
   // CHECK-START: void Main.loop8() liveness (after)
-  // CHECK:         StaticFieldGet  liveness:12 ranges:[ 12-44 ] uses:[ 35 40 44 ]
+  // CHECK:         StaticFieldGet  liveness:12 ranges:[12-44] uses:[35,40,44]
   // CHECK:         Goto            liveness:38
   // CHECK:         Goto            liveness:42
   public static void loop8() {
@@ -114,7 +114,7 @@
   }
 
   // CHECK-START: void Main.loop9() liveness (after)
-  // CHECK:         StaticFieldGet  liveness:22 ranges:[ 22-36 ] uses:[ 31 36 ]
+  // CHECK:         StaticFieldGet  liveness:22 ranges:[22-36] uses:[31,36]
   // CHECK:         Goto            liveness:38
   public static void loop9() {
     while (Runtime.getRuntime() != null) {
diff --git a/test/485-checker-dce-loop-update/smali/TestCase.smali b/test/485-checker-dce-loop-update/smali/TestCase.smali
index bdc4038..71da510 100644
--- a/test/485-checker-dce-loop-update/smali/TestCase.smali
+++ b/test/485-checker-dce-loop-update/smali/TestCase.smali
@@ -29,21 +29,21 @@
 # CHECK-DAG:     <<Cst1:i\d+>>  IntConstant 1
 # CHECK-DAG:     <<Cst5:i\d+>>  IntConstant 5
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
-# CHECK-DAG:     <<PhiX:i\d+>>  Phi [ <<ArgX>> <<Add5:i\d+>> <<Add7:i\d+>> ] loop:<<HeaderY:B\d+>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<Cst1>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Add5>>       Add [ <<PhiX>> <<Cst5>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX>> <<Cst7>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:                    Return [ <<PhiX>> ]                          loop:none
+# CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<Cst1>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Add5>>       Add [<<PhiX>>,<<Cst5>>]                    loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
+# CHECK-DAG:                    Return [<<PhiX>>]                          loop:none
 
 # CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (after)
 # CHECK-DAG:     <<ArgX:i\d+>>  ParameterValue
 # CHECK-DAG:     <<ArgY:z\d+>>  ParameterValue
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
-# CHECK-DAG:     <<PhiX:i\d+>>  Phi [ <<ArgX>> <<AddX:i\d+>> ]               loop:<<HeaderY:B\d+>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<AddX>>       Add [ <<PhiX>> <<Cst7>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:                    Return [ <<PhiX>> ]                          loop:none
+# CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<AddX:i\d+>>]               loop:<<HeaderY:B\d+>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<AddX>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
+# CHECK-DAG:                    Return [<<PhiX>>]                          loop:none
 
 .method public static testSingleExit(IZ)I
   .registers 3
@@ -80,24 +80,24 @@
 # CHECK-DAG:     <<Cst1:i\d+>>  IntConstant 1
 # CHECK-DAG:     <<Cst5:i\d+>>  IntConstant 5
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
-# CHECK-DAG:     <<PhiX:i\d+>>  Phi [ <<ArgX>> <<Add5:i\d+>> <<Add7:i\d+>> ] loop:<<HeaderY:B\d+>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<ArgZ>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<Cst1>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Add5>>       Add [ <<PhiX>> <<Cst5>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX>> <<Cst7>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:                    Return [ <<PhiX>> ]                          loop:none
+# CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<ArgZ>>]                              loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<Cst1>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Add5>>       Add [<<PhiX>>,<<Cst5>>]                    loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
+# CHECK-DAG:                    Return [<<PhiX>>]                          loop:none
 
 # CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (after)
 # CHECK-DAG:     <<ArgX:i\d+>>  ParameterValue
 # CHECK-DAG:     <<ArgY:z\d+>>  ParameterValue
 # CHECK-DAG:     <<ArgZ:z\d+>>  ParameterValue
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
-# CHECK-DAG:     <<PhiX:i\d+>>  Phi [ <<ArgX>> <<Add7:i\d+>> ]               loop:<<HeaderY:B\d+>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX>> <<Cst7>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<ArgZ>> ]                              loop:none
-# CHECK-DAG:                    Return [ <<PhiX>> ]                          loop:none
+# CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add7:i\d+>>]               loop:<<HeaderY:B\d+>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<ArgZ>>]                              loop:none
+# CHECK-DAG:                    Return [<<PhiX>>]                          loop:none
 
 .method public static testMultipleExits(IZZ)I
   .registers 4
@@ -137,15 +137,15 @@
 # CHECK-DAG:     <<Cst5:i\d+>>  IntConstant 5
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
 # CHECK-DAG:     <<Cst9:i\d+>>  IntConstant 9
-# CHECK-DAG:     <<PhiX1:i\d+>> Phi [ <<ArgX>> <<Add5:i\d+>> <<Add7:i\d+>> ] loop:<<HeaderY:B\d+>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<ArgZ>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Mul9:i\d+>>  Mul [ <<PhiX1>> <<Cst9>> ]                   loop:<<HeaderY>>
-# CHECK-DAG:     <<PhiX2:i\d+>> Phi [ <<Mul9>> <<PhiX1>> ]                   loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<Cst1>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Add5>>       Add [ <<PhiX2>> <<Cst5>> ]                   loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX1>> <<Cst7>> ]                   loop:<<HeaderY>>
-# CHECK-DAG:                    Return [ <<PhiX2>> ]                         loop:none
+# CHECK-DAG:     <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<ArgZ>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Mul9:i\d+>>  Mul [<<PhiX1>>,<<Cst9>>]                   loop:<<HeaderY>>
+# CHECK-DAG:     <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>]                   loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<Cst1>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Add5>>       Add [<<PhiX2>>,<<Cst5>>]                   loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX1>>,<<Cst7>>]                   loop:<<HeaderY>>
+# CHECK-DAG:                    Return [<<PhiX2>>]                         loop:none
 
 # CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (after)
 # CHECK-DAG:     <<ArgX:i\d+>>  ParameterValue
@@ -153,13 +153,13 @@
 # CHECK-DAG:     <<ArgZ:z\d+>>  ParameterValue
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
 # CHECK-DAG:     <<Cst9:i\d+>>  IntConstant 9
-# CHECK-DAG:     <<PhiX1:i\d+>> Phi [ <<ArgX>> <<Add7:i\d+>> ]               loop:<<HeaderY:B\d+>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX1>> <<Cst7>> ]                   loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<ArgZ>> ]                              loop:none
-# CHECK-DAG:     <<Mul9:i\d+>>  Mul [ <<PhiX1>> <<Cst9>> ]                   loop:none
-# CHECK-DAG:     <<PhiX2:i\d+>> Phi [ <<Mul9>> <<PhiX1>> ]                   loop:none
-# CHECK-DAG:                    Return [ <<PhiX2>> ]                         loop:none
+# CHECK-DAG:     <<PhiX1:i\d+>> Phi [<<ArgX>>,<<Add7:i\d+>>]               loop:<<HeaderY:B\d+>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX1>>,<<Cst7>>]                   loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<ArgZ>>]                              loop:none
+# CHECK-DAG:     <<Mul9:i\d+>>  Mul [<<PhiX1>>,<<Cst9>>]                   loop:none
+# CHECK-DAG:     <<PhiX2:i\d+>> Phi [<<Mul9>>,<<PhiX1>>]                   loop:none
+# CHECK-DAG:                    Return [<<PhiX2>>]                         loop:none
 
 .method public static testExitPredecessors(IZZ)I
   .registers 4
@@ -205,19 +205,19 @@
 # CHECK-DAG:     <<Cst5:i\d+>>  IntConstant 5
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
 #
-# CHECK-DAG:     <<PhiX:i\d+>>  Phi [ <<ArgX>> <<Add5:i\d+>> <<Add7:i\d+>> ] loop:<<HeaderY:B\d+>>
-# CHECK-DAG:     <<PhiZ1:i\d+>> Phi [ <<ArgZ>> <<XorZ:i\d+>> <<PhiZ1>> ]     loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
+# CHECK-DAG:     <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<XorZ:i\d+>>,<<PhiZ1>>]     loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
 #
 #                               ### Inner loop ###
-# CHECK-DAG:     <<PhiZ2:i\d+>> Phi [ <<PhiZ1>> <<XorZ>> ]                   loop:<<HeaderZ:B\d+>>
-# CHECK-DAG:     <<XorZ>>       Xor [ <<PhiZ2>> <<Cst1>> ]                   loop:<<HeaderZ>>
-# CHECK-DAG:     <<CondZ:z\d+>> Equal [ <<XorZ>> <<Cst0>> ]                  loop:<<HeaderZ>>
-# CHECK-DAG:                    If [ <<CondZ>> ]                             loop:<<HeaderZ>>
+# CHECK-DAG:     <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ>>]                   loop:<<HeaderZ:B\d+>>
+# CHECK-DAG:     <<XorZ>>       Xor [<<PhiZ2>>,<<Cst1>>]                   loop:<<HeaderZ>>
+# CHECK-DAG:     <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>]                  loop:<<HeaderZ>>
+# CHECK-DAG:                    If [<<CondZ>>]                             loop:<<HeaderZ>>
 #
-# CHECK-DAG:     <<Add5>>       Add [ <<PhiX>> <<Cst5>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX>> <<Cst7>> ]                    loop:<<HeaderY>>
-# CHECK-DAG:                    Return [ <<PhiX>> ]                          loop:none
+# CHECK-DAG:     <<Add5>>       Add [<<PhiX>>,<<Cst5>>]                    loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
+# CHECK-DAG:                    Return [<<PhiX>>]                          loop:none
 
 # CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after)
 # CHECK-DAG:     <<ArgX:i\d+>>  ParameterValue
@@ -227,18 +227,18 @@
 # CHECK-DAG:     <<Cst1:i\d+>>  IntConstant 1
 # CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
 #
-# CHECK-DAG:     <<PhiX:i\d+>>  Phi [ <<ArgX>> <<Add7:i\d+>> ]               loop:<<HeaderY:B\d+>>
-# CHECK-DAG:     <<PhiZ1:i\d+>> Phi [ <<ArgZ>> <<PhiZ1>> ]                   loop:<<HeaderY>>
-# CHECK-DAG:                    If [ <<ArgY>> ]                              loop:<<HeaderY>>
-# CHECK-DAG:     <<Add7>>       Add [ <<PhiX>> <<Cst7>> ]                    loop:<<HeaderY>>
+# CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add7:i\d+>>]               loop:<<HeaderY:B\d+>>
+# CHECK-DAG:     <<PhiZ1:i\d+>> Phi [<<ArgZ>>,<<PhiZ1>>]                   loop:<<HeaderY>>
+# CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+# CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
 #
 #                               ### Inner loop ###
-# CHECK-DAG:     <<PhiZ2:i\d+>> Phi [ <<PhiZ1>> <<XorZ:i\d+>> ]              loop:<<HeaderZ:B\d+>>
-# CHECK-DAG:     <<XorZ>>       Xor [ <<PhiZ2>> <<Cst1>> ]                   loop:<<HeaderZ>>
-# CHECK-DAG:     <<CondZ:z\d+>> Equal [ <<XorZ>> <<Cst0>> ]                  loop:<<HeaderZ>>
-# CHECK-DAG:                    If [ <<CondZ>> ]                             loop:<<HeaderZ>>
+# CHECK-DAG:     <<PhiZ2:i\d+>> Phi [<<PhiZ1>>,<<XorZ:i\d+>>]              loop:<<HeaderZ:B\d+>>
+# CHECK-DAG:     <<XorZ>>       Xor [<<PhiZ2>>,<<Cst1>>]                   loop:<<HeaderZ>>
+# CHECK-DAG:     <<CondZ:z\d+>> Equal [<<XorZ>>,<<Cst0>>]                  loop:<<HeaderZ>>
+# CHECK-DAG:                    If [<<CondZ>>]                             loop:<<HeaderZ>>
 #
-# CHECK-DAG:                    Return [ <<PhiX>> ]                          loop:none
+# CHECK-DAG:                    Return [<<PhiX>>]                          loop:none
 
 .method public static testInnerLoop(IZZ)I
   .registers 4