Update tests.

test/libyul/yulOptimizerTests/blockFlattener/basic.yul

@@ -1,21 +1,25 @@
 {
-  let _1 := mload(0)
-  let f_a := mload(1)
-  let f_r
   {
-    f_a := mload(f_a)
+    let _1 := mload(0)
-    f_r := add(f_a, calldatasize())
+    let f_a := mload(1)
+    let f_r
+    {
+      f_a := mload(f_a)
+      f_r := add(f_a, calldatasize())
+    }
+    let z := mload(2)
   }
-  let z := mload(2)
 }
 // ----
 // step: blockFlattener
 //
 // {
-//     let _1 := mload(0)
+//     {
-//     let f_a := mload(1)
+//         let _1 := mload(0)
-//     let f_r
+//         let f_a := mload(1)
-//     f_a := mload(f_a)
+//         let f_r
-//     f_r := add(f_a, calldatasize())
+//         f_a := mload(f_a)
-//     let z := mload(2)
+//         f_r := add(f_a, calldatasize())
+//         let z := mload(2)
+//     }
 // }

test/libyul/yulOptimizerTests/blockFlattener/for_stmt.yul

@@ -1,12 +1,16 @@
 {
-    for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+    {
-        a := add(a, 1)
+        for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) } {
+            a := add(a, 1)
+        }
     }
 }
 // ----
 // step: blockFlattener
 //
 // {
-//     for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) }
+//     {
-//     { a := add(a, 1) }
+//         for { let a := 1 } iszero(eq(a, 10)) { a := add(a, 1) }
+//         { a := add(a, 1) }
+//     }
 // }

test/libyul/yulOptimizerTests/blockFlattener/if_stmt.yul

@@ -1,21 +1,25 @@
 {
-  if add(mload(7), sload(mload(3)))
   {
-    let y := add(mload(3), 3)
+    if add(mload(7), sload(mload(3)))
-	{
+    {
-      y := add(y, 7)
+      let y := add(mload(3), 3)
-	}
+      {
+        y := add(y, 7)
+      }
+    }
+    let t := add(3, 9)
   }
-  let t := add(3, 9)
 }
 // ----
 // step: blockFlattener
 //
 // {
-//     if add(mload(7), sload(mload(3)))
 //     {
-//         let y := add(mload(3), 3)
+//         if add(mload(7), sload(mload(3)))
-//         y := add(y, 7)
+//         {
+//             let y := add(mload(3), 3)
+//             y := add(y, 7)
+//         }
+//         let t := add(3, 9)
 //     }
-//     let t := add(3, 9)
 // }

test/libyul/yulOptimizerTests/blockFlattener/many_nested_blocks.yul

@@ -1,29 +1,33 @@
 {
-  let a := 3
-  let b := 4
   {
-    a := add(b, 3)
+    let a := 3
-    let c := 5
+    let b := 4
     {
-      b := add(b, 4)
+      a := add(b, 3)
+      let c := 5
       {
-        c := add(a, 5)
+        b := add(b, 4)
-	  }
+        {
-      b := add(a, b)
+          c := add(a, 5)
+        }
+        b := add(a, b)
+      }
+      a := add(a, c)
     }
-    a := add(a, c)
   }
 }
 // ----
 // step: blockFlattener
 //
 // {
-//     let a := 3
+//     {
-//     let b := 4
+//         let a := 3
-//     a := add(b, 3)
+//         let b := 4
-//     let c := 5
+//         a := add(b, 3)
-//     b := add(b, 4)
+//         let c := 5
-//     c := add(a, 5)
+//         b := add(b, 4)
-//     b := add(a, b)
+//         c := add(a, 5)
-//     a := add(a, c)
+//         b := add(a, b)
+//         a := add(a, c)
+//     }
 // }

test/libyul/yulOptimizerTests/blockFlattener/switch_stmt.yul

@@ -1,23 +1,27 @@
 {
+  {
     let a := 1
     switch calldataload(0)
     case 0 { { { mstore(0, 1) } } a := 8 }
     default { a := 3 { a := 4 } }
     a := 5
+  }
 }
 // ----
 // step: blockFlattener
 //
 // {
-//     let a := 1
+//     {
-//     switch calldataload(0)
+//         let a := 1
-//     case 0 {
+//         switch calldataload(0)
-//         mstore(0, 1)
+//         case 0 {
-//         a := 8
+//             mstore(0, 1)
+//             a := 8
+//         }
+//         default {
+//             a := 3
+//             a := 4
+//         }
+//         a := 5
 //     }
-//     default {
-//         a := 3
-//         a := 4
-//     }
-//     a := 5
 // }

test/libyul/yulOptimizerTests/circularReferencesPruner/called_from_non_function.yul

@@ -9,8 +9,10 @@
 // step: circularReferencesPruner
 //
 // {
-//     let a
+//     {
-//     a := h()
+//         let a
+//         a := h()
+//     }
 //     function f() -> x
 //     { x := g() }
 //     function g() -> y

test/libyul/yulOptimizerTests/circularReferencesPruner/nested_different_names.yul

@@ -11,4 +11,4 @@
 // ----
 // step: circularReferencesPruner
 //
-// { }
+// { { } }

test/libyul/yulOptimizerTests/circularReferencesPruner/nested_same_name.yul

@@ -11,4 +11,4 @@
 // ----
 // step: circularReferencesPruner
 //
-// { }
+// { { } }

test/libyul/yulOptimizerTests/circularReferencesPruner/trivial.yul

@@ -5,4 +5,4 @@
 // ----
 // step: circularReferencesPruner
 //
-// { }
+// { { } }

test/libyul/yulOptimizerTests/expressionJoiner/if_condition.yul

@@ -14,6 +14,8 @@
 // step: expressionJoiner
 //
 // {
-//     if add(mload(7), sload(mload(3))) { let y := add(mload(3), 3) }
+//     {
-//     let t := add(3, 9)
+//         if add(mload(7), sload(mload(3))) { let y := add(mload(3), 3) }
+//         let t := add(3, 9)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/muli_wrong_order3.yul

@@ -8,7 +8,9 @@
 // step: expressionJoiner
 //
 // {
-//     let a := mload(3)
+//     {
-//     let b := mload(6)
+//         let a := mload(3)
-//     sstore(mul(add(b, a), mload(2)), 3)
+//         let b := mload(6)
+//         sstore(mul(add(b, a), mload(2)), 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/multi.yul

@@ -8,5 +8,7 @@
 // step: expressionJoiner
 //
 // {
-//     sstore(mul(add(mload(6), mload(2)), 2), 3)
+//     {
+//         sstore(mul(add(mload(6), mload(2)), 2), 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/multi_reference.yul

@@ -7,6 +7,8 @@
 // step: expressionJoiner
 //
 // {
-//     let a := mload(2)
+//     {
-//     let b := add(a, a)
+//         let a := mload(2)
+//         let b := add(a, a)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/multi_wrong_order.yul

@@ -11,6 +11,8 @@
 // step: expressionJoiner
 //
 // {
-//     let a := mload(2)
+//     {
-//     sstore(mul(a, add(2, mload(6))), 3)
+//         let a := mload(2)
+//         sstore(mul(a, add(2, mload(6))), 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/multi_wrong_order2.yul

@@ -8,6 +8,8 @@
 // step: expressionJoiner
 //
 // {
-//     let a := mload(2)
+//     {
-//     sstore(mul(add(a, mload(6)), 2), 3)
+//         let a := mload(2)
+//         sstore(mul(add(a, mload(6)), 2), 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_across_blocks.yul

@@ -15,6 +15,8 @@
 // step: expressionJoiner
 //
 // {
-//     let x := calldataload(mload(2))
+//     {
-//     sstore(x, 3)
+//         let x := calldataload(mload(2))
+//         sstore(x, 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_in_loop_condition1.yul

@@ -5,6 +5,8 @@
 // step: expressionJoiner
 //
 // {
-//     for { let b := mload(1) } b { }
+//     {
-//     { }
+//         for { let b := mload(1) } b { }
+//         { }
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_in_loop_condition2.yul

@@ -6,7 +6,9 @@
 // step: expressionJoiner
 //
 // {
-//     let a := mload(0)
+//     {
-//     for { } a { }
+//         let a := mload(0)
-//     { }
+//         for { } a { }
+//         { }
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/only_assignment.yul

@@ -9,6 +9,7 @@
 // step: expressionJoiner
 //
 // {
+//     { }
 //     function f(a) -> x
 //     {
 //         a := mload(2)

test/libyul/yulOptimizerTests/expressionJoiner/reassignment.yul

@@ -8,7 +8,9 @@
 // step: expressionJoiner
 //
 // {
-//     let a := mload(2)
+//     {
-//     let b := mload(a)
+//         let a := mload(2)
-//     a := 4
+//         let b := mload(a)
+//         a := 4
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/simple.yul

@@ -7,5 +7,7 @@
 // step: expressionJoiner
 //
 // {
-//     sstore(calldataload(mload(2)), 3)
+//     {
+//         sstore(calldataload(mload(2)), 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/single_wrong_order.yul

@@ -9,6 +9,8 @@
 // step: expressionJoiner
 //
 // {
-//     let b := sload(mload(3))
+//     {
-//     sstore(add(b, mload(7)), 0)
+//         let b := sload(mload(3))
+//         sstore(add(b, mload(7)), 0)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/smoke.yul

@@ -2,4 +2,4 @@
 // ----
 // step: expressionJoiner
 //
-// { }
+// { { } }

test/libyul/yulOptimizerTests/expressionJoiner/switch_expression.yul

@@ -18,8 +18,10 @@
 // step: expressionJoiner
 //
 // {
-//     switch add(mload(7), sload(mload(3)))
+//     {
-//     case 3 { let y := add(mload(3), 3) }
+//         switch add(mload(7), sload(mload(3)))
-//     default { sstore(1, 0) }
+//         case 3 { let y := add(mload(3), 3) }
-//     let t := add(3, 9)
+//         default { sstore(1, 0) }
+//         let t := add(3, 9)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionJoiner/triple.yul

@@ -9,5 +9,7 @@
 // step: expressionJoiner
 //
 // {
-//     sstore(mul(add(mload(7), mload(6)), mload(2)), 3)
+//     {
+//         sstore(mul(add(mload(7), mload(6)), mload(2)), 3)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/assigned_vars_multi.yul

@@ -8,8 +8,10 @@
 // step: expressionSimplifier
 //
 // {
-//     let c, d := f()
+//     {
-//     sstore(add(add(d, c), 7), 20)
+//         let c, d := f()
+//         sstore(add(add(d, c), 7), 20)
+//     }
 //     function f() -> x, z
 //     { }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/byte_after_shr_non_mul_of_8.yul

@@ -6,4 +6,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, 0) }
+// { { sstore(0, 0) } }

test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and.yul

@@ -13,7 +13,9 @@
 // step: expressionSimplifier
 //
 // {
-//     let x := calldataload(0)
+//     {
-//     let a := and(0xff, and(shr(248, x), 255))
+//         let x := calldataload(0)
-//     sstore(a, shr(12, and(shl(8, x), 15790080)))
+//         let a := and(0xff, and(shr(248, x), 255))
+//         sstore(a, shr(12, and(shl(8, x), 15790080)))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and_2.yul

@@ -24,25 +24,27 @@
 // step: expressionSimplifier
 //
 // {
-//     let x := calldataload(0)
+//     {
-//     let _2 := 0xf
+//         let x := calldataload(0)
-//     let _5 := and(shr(248, x), 0)
+//         let _2 := 0xf
-//     let _10 := 0xff
+//         let _5 := and(shr(248, x), 0)
-//     let a := and(_5, 255)
+//         let _10 := 0xff
-//     let _14 := and(shr(4, x), 3855)
+//         let a := and(_5, 255)
-//     let _15 := 12
+//         let _14 := and(shr(4, x), 3855)
-//     let b := shl(_15, _14)
+//         let _15 := 12
-//     let _19 := and(shr(4, x), 3855)
+//         let b := shl(_15, _14)
-//     let c := shl(_15, _19)
+//         let _19 := and(shr(4, x), 3855)
-//     let d := shl(_15, and(shr(255, x), 0))
+//         let c := shl(_15, _19)
-//     let e := shl(_10, _19)
+//         let d := shl(_15, and(shr(255, x), 0))
-//     let f := 0
+//         let e := shl(_10, _19)
-//     let g := 0
+//         let f := 0
-//     sstore(10, a)
+//         let g := 0
-//     sstore(11, b)
+//         sstore(10, a)
-//     sstore(_15, c)
+//         sstore(11, b)
-//     sstore(13, d)
+//         sstore(_15, c)
-//     sstore(14, e)
+//         sstore(13, d)
-//     sstore(_2, f)
+//         sstore(14, e)
-//     sstore(16, g)
+//         sstore(_2, f)
+//         sstore(16, g)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/combine_shift_and_and_3.yul

@@ -21,17 +21,19 @@
 // step: expressionSimplifier
 //
 // {
-//     let x := calldataload(0)
+//     {
-//     let a := and(shl(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000)
+//         let x := calldataload(0)
-//     let b := and(shr(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0)
+//         let a := and(shl(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000)
-//     let c := and(shr(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//         let b := and(shr(8, x), 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0)
-//     let d := and(shl(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)
+//         let c := and(shr(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
-//     let _14 := 150
+//         let d := and(shl(8, x), 0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)
-//     let e := shl(_14, and(shl(148, x), 0x3ffffffffffffffffffffffffff0000000000000000000000000000000000000))
+//         let _14 := 150
-//     sstore(15, x)
+//         let e := shl(_14, and(shl(148, x), 0x3ffffffffffffffffffffffffff0000000000000000000000000000000000000))
-//     sstore(16, a)
+//         sstore(15, x)
-//     sstore(17, b)
+//         sstore(16, a)
-//     sstore(18, c)
+//         sstore(17, b)
-//     sstore(19, d)
+//         sstore(18, c)
-//     sstore(20, e)
+//         sstore(19, d)
+//         sstore(20, e)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/constant_propagation.yul

@@ -5,4 +5,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { mstore(20, mload(0)) }
+// { { mstore(20, mload(0)) } }

test/libyul/yulOptimizerTests/expressionSimplifier/constants.yul

@@ -5,4 +5,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(7, 13) }
+// { { sstore(7, 13) } }

test/libyul/yulOptimizerTests/expressionSimplifier/create2_and_mask.yul

@@ -12,9 +12,11 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0xffffffffffffffffffffffffffffffffffffffff
+//     {
-//     let _2 := 0
+//         let _1 := 0xffffffffffffffffffffffffffffffffffffffff
-//     let _3 := 0x20
+//         let _2 := 0
-//     let a := and(create2(_2, _2, _3, _2), _1)
+//         let _3 := 0x20
-//     sstore(a, and(_1, create2(_2, _2, _3, _2)))
+//         let a := and(create2(_2, _2, _3, _2), _1)
+//         sstore(a, and(_1, create2(_2, _2, _3, _2)))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/create_and_mask.yul

@@ -11,10 +11,12 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0x20
+//     {
-//     let _2 := 0
+//         let _1 := 0x20
-//     let c := create(_2, _2, _1)
+//         let _2 := 0
-//     let _4 := 0xffffffffffffffffffffffffffffffffffffffff
+//         let c := create(_2, _2, _1)
-//     let a := and(c, _4)
+//         let _4 := 0xffffffffffffffffffffffffffffffffffffffff
-//     sstore(a, and(_4, create(_2, _2, _1)))
+//         let a := and(c, _4)
+//         sstore(a, and(_4, create(_2, _2, _1)))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/exp_simplifications.yul

@@ -13,12 +13,14 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     let t := calldataload(_1)
+//         let _1 := 0
-//     sstore(_1, iszero(t))
+//         let t := calldataload(_1)
-//     sstore(1, 1)
+//         sstore(_1, iszero(t))
-//     let _8 := 2
+//         sstore(1, 1)
-//     sstore(_8, shl(t, 1))
+//         let _8 := 2
-//     sstore(3, exp(8, t))
+//         sstore(_8, shl(t, 1))
-//     sstore(4, sub(iszero(and(t, 1)), and(t, 1)))
+//         sstore(3, exp(8, t))
+//         sstore(4, sub(iszero(and(t, 1)), and(t, 1)))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/idempotency.yul

@@ -9,8 +9,10 @@
 // step: expressionSimplifier
 //
 // {
-//     let x := calldataload(0)
+//     {
-//     let z := calldataload(1)
+//         let x := calldataload(0)
-//     let t := and(x, z)
+//         let z := calldataload(1)
-//     sstore(t, or(x, z))
+//         let t := and(x, z)
+//         sstore(t, or(x, z))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_complex.yul

@@ -5,4 +5,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, 0) }
+// { { sstore(0, 0) } }

test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_negative.yul

@@ -6,6 +6,8 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     sstore(_1, sub(calldataload(1), calldataload(_1)))
+//         let _1 := 0
+//         sstore(_1, sub(calldataload(1), calldataload(_1)))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_simple.yul

@@ -6,4 +6,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, 0) }
+// { { sstore(0, 0) } }

test/libyul/yulOptimizerTests/expressionSimplifier/including_function_calls.yul

@@ -7,7 +7,7 @@
 // step: expressionSimplifier
 //
 // {
-//     sstore(0, f())
+//     { sstore(0, f()) }
 //     function f() -> a
 //     { }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/inside_for.yul

@@ -6,7 +6,9 @@
 // step: expressionSimplifier
 //
 // {
-//     let a := 10
+//     {
-//     for { } iszero(iszero(a)) { a := add(a, 1) }
+//         let a := 10
-//     { }
+//         for { } iszero(iszero(a)) { a := add(a, 1) }
+//         { }
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/invariant.yul

@@ -6,4 +6,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, mload(0)) }
+// { { sstore(0, mload(0)) } }

test/libyul/yulOptimizerTests/expressionSimplifier/iszero_sub_to_eq.yul

@@ -10,7 +10,9 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     let a := calldataload(_1)
+//         let _1 := 0
-//     if eq(a, calldataload(0x20)) { sstore(_1, 1) }
+//         let a := calldataload(_1)
+//         if eq(a, calldataload(0x20)) { sstore(_1, 1) }
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/large_byte_access.yul

@@ -13,14 +13,16 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     let a := calldataload(_1)
+//         let _1 := 0
-//     let b := 0
+//         let a := calldataload(_1)
-//     let c := byte(20, a)
+//         let b := 0
-//     pop(create(_1, _1, 0x20))
+//         let c := byte(20, a)
-//     let d := 0
+//         pop(create(_1, _1, 0x20))
-//     sstore(7, a)
+//         let d := 0
-//     sstore(8, b)
+//         sstore(7, a)
-//     sstore(9, c)
+//         sstore(8, b)
-//     sstore(10, d)
+//         sstore(9, c)
+//         sstore(10, d)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_1.yul

@@ -5,6 +5,8 @@
 // step: expressionSimplifier
 //
 // {
-//     let _4 := 0
+//     {
-//     mstore(_4, and(calldataload(_4), 255))
+//         let _4 := 0
+//         mstore(_4, and(calldataload(_4), 255))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_2.yul

@@ -5,6 +5,8 @@
 // step: expressionSimplifier
 //
 // {
-//     let _4 := 0
+//     {
-//     mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
+//         let _4 := 0
+//         mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_arguments.yul

@@ -7,9 +7,11 @@
 // step: expressionSimplifier
 //
 // {
-//     let _2 := f(1)
+//     {
-//     let _3 := 0
+//         let _2 := f(1)
-//     sstore(_3, sub(f(_3), _2))
+//         let _3 := 0
+//         sstore(_3, sub(f(_3), _2))
+//     }
 //     function f(a) -> b
 //     { }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_names.yul

@@ -8,7 +8,7 @@
 // step: expressionSimplifier
 //
 // {
-//     sstore(0, sub(f1(), f2()))
+//     { sstore(0, sub(f1(), f2())) }
 //     function f1() -> a
 //     { }
 //     function f2() -> b

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_equality_not_movable.yul

@@ -8,7 +8,7 @@
 // step: expressionSimplifier
 //
 // {
-//     sstore(sub(f(), f()), 8)
+//     { sstore(sub(f(), f()), 8) }
 //     function f() -> a
 //     { mstore(0, 1) }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_removes_non_constant_and_not_movable.yul

@@ -9,9 +9,11 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := msize()
+//     {
-//     let _2 := 0
+//         let _1 := msize()
-//     sstore(_2, _1)
+//         let _2 := 0
-//     pop(keccak256(_2, _2))
+//         sstore(_2, _1)
-//     sstore(20, 0)
+//         pop(keccak256(_2, _2))
+//         sstore(20, 0)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_call.yul

@@ -7,7 +7,9 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     pop(call(_1, _1, _1, _1, _1, _1, _1))
+//         let _1 := 0
-//     sstore(_1, 0)
+//         pop(call(_1, _1, _1, _1, _1, _1, _1))
+//         sstore(_1, 0)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_func.yul

@@ -8,8 +8,10 @@
 // step: expressionSimplifier
 //
 // {
-//     pop(f())
+//     {
-//     mstore(0, 0)
+//         pop(f())
+//         mstore(0, 0)
+//     }
 //     function f() -> x
 //     { mstore(0, 1337) }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/pop_byte_shr_func_trivial.yul

@@ -7,4 +7,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, 0) }
+// { { sstore(0, 0) } }

test/libyul/yulOptimizerTests/expressionSimplifier/reassign.yul

@@ -7,8 +7,10 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     let x := mload(_1)
+//         let _1 := 0
-//     x := _1
+//         let x := mload(_1)
-//     mstore(_1, 7)
+//         x := _1
+//         mstore(_1, 7)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/remove_redundant_shift_masking.yul

@@ -12,12 +12,14 @@
 // step: expressionSimplifier
 //
 // {
-//     let _2 := calldataload(0)
+//     {
-//     let _5 := 0xff
+//         let _2 := calldataload(0)
-//     let a := shr(248, _2)
+//         let _5 := 0xff
-//     let b := shr(248, _2)
+//         let a := shr(248, _2)
-//     let c := and(shr(249, _2), 0xfa)
+//         let b := shr(248, _2)
-//     let d := and(shr(247, _2), _5)
+//         let c := and(shr(249, _2), 0xfa)
-//     sstore(a, b)
+//         let d := and(shr(247, _2), _5)
-//     sstore(c, d)
+//         sstore(a, b)
+//         sstore(c, d)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/replace_too_large_shift.yul

@@ -12,12 +12,14 @@
 // step: expressionSimplifier
 //
 // {
-//     let a := 0
+//     {
-//     let b := 0
+//         let a := 0
-//     let _8 := calldataload(2)
+//         let b := 0
-//     let _9 := 255
+//         let _8 := calldataload(2)
-//     let c := shl(_9, _8)
+//         let _9 := 255
-//     let d := shr(_9, calldataload(3))
+//         let c := shl(_9, _8)
-//     sstore(a, b)
+//         let d := shr(_9, calldataload(3))
-//     sstore(c, d)
+//         sstore(a, b)
+//         sstore(c, d)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/return_vars_zero.yul

@@ -10,7 +10,7 @@
 // step: expressionSimplifier
 //
 // {
-//     let t, v := f()
+//     { let t, v := f() }
 //     function f() -> c, d
 //     { sstore(0, 7) }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/reversed.yul

@@ -6,6 +6,8 @@
 // step: expressionSimplifier
 //
 // {
-//     let _1 := 0
+//     {
-//     sstore(_1, mload(_1))
+//         let _1 := 0
+//         sstore(_1, mload(_1))
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_not_supported.yul

@@ -6,4 +6,6 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, balance(address())) }
+// {
+//     { sstore(0, balance(address())) }
+// }

test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_split.yul

@@ -9,6 +9,8 @@
 // step: expressionSimplifier
 //
 // {
-//     let a := address()
+//     {
-//     sstore(a, selfbalance())
+//         let a := address()
+//         sstore(a, selfbalance())
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/selfbalance_supported.yul

@@ -6,4 +6,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(0, selfbalance()) }
+// { { sstore(0, selfbalance()) } }

test/libyul/yulOptimizerTests/expressionSimplifier/side_effects_in_for_condition.yul

@@ -9,6 +9,8 @@
 // step: expressionSimplifier
 //
 // {
-//     for { } div(create(0, 1, 0), shl(msize(), 1)) { }
+//     {
-//     { }
+//         for { } div(create(0, 1, 0), shl(msize(), 1)) { }
+//         { }
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/smoke.yul

@@ -2,4 +2,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { }
+// { { } }

test/libyul/yulOptimizerTests/expressionSimplifier/unassigend_vars_multi.yul

@@ -8,6 +8,8 @@
 // step: expressionSimplifier
 //
 // {
-//     let c, d
+//     {
-//     sstore(d, 7)
+//         let c, d
+//         sstore(d, 7)
+//     }
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/unassigned_vars.yul

@@ -8,4 +8,4 @@
 // ----
 // step: expressionSimplifier
 //
-// { sstore(8, 7) }
+// { { sstore(8, 7) } }

test/libyul/yulOptimizerTests/fullInliner/no_inline_into_big_function.yul

@@ -13,6 +13,7 @@
 // step: fullInliner
 //
 // {
+//     { }
 //     function f(a) -> b
 //     { b := sload(mload(a)) }
 //     function g() -> x_1

test/libyul/yulOptimizerTests/fullSimplify/constant_propagation.yul

@@ -6,6 +6,8 @@
 // step: fullSimplify
 //
 // {
-//     let _2 := 0
+//     {
-//     mstore(mload(_2), _2)
+//         let _2 := 0
+//         mstore(mload(_2), _2)
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/constants.yul

@@ -5,4 +5,4 @@
 // ----
 // step: fullSimplify
 //
-// { mstore(0, 13) }
+// { { mstore(0, 13) } }

test/libyul/yulOptimizerTests/fullSimplify/identity_rules_complex.yul

@@ -5,4 +5,4 @@
 // ----
 // step: fullSimplify
 //
-// { mstore(0, 0) }
+// { { mstore(0, 0) } }

test/libyul/yulOptimizerTests/fullSimplify/identity_rules_negative.yul

@@ -6,6 +6,8 @@
 // step: fullSimplify
 //
 // {
-//     let _1 := 0
+//     {
-//     mstore(_1, sub(calldataload(1), calldataload(_1)))
+//         let _1 := 0
+//         mstore(_1, sub(calldataload(1), calldataload(_1)))
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/identity_rules_simple.yul

@@ -5,4 +5,4 @@
 // ----
 // step: fullSimplify
 //
-// { mstore(0, 0) }
+// { { mstore(0, 0) } }

test/libyul/yulOptimizerTests/fullSimplify/including_function_calls.yul

@@ -7,7 +7,7 @@
 // step: fullSimplify
 //
 // {
-//     mstore(f(), 0)
+//     { mstore(f(), 0) }
 //     function f() -> a
 //     { }
 // }

test/libyul/yulOptimizerTests/fullSimplify/inside_for.yul

@@ -7,7 +7,9 @@
 // step: fullSimplify
 //
 // {
-//     let a := 10
+//     {
-//     for { } iszero(iszero(a)) { a := add(a, 1) }
+//         let a := 10
-//     { }
+//         for { } iszero(iszero(a)) { a := add(a, 1) }
+//         { }
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/invariant.yul

@@ -11,8 +11,10 @@
 // step: fullSimplify
 //
 // {
-//     let a := calldataload(0)
+//     {
-//     let _4 := 0
+//         let a := calldataload(0)
-//     let b := a
+//         let _4 := 0
-//     mstore(b, eq(calldataload(_4), a))
+//         let b := a
+//         mstore(b, eq(calldataload(_4), a))
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/mod_and_1.yul

@@ -5,6 +5,8 @@
 // step: fullSimplify
 //
 // {
-//     let _4 := 0
+//     {
-//     mstore(_4, and(calldataload(_4), 255))
+//         let _4 := 0
+//         mstore(_4, and(calldataload(_4), 255))
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/mod_and_2.yul

@@ -5,6 +5,8 @@
 // step: fullSimplify
 //
 // {
-//     let _4 := 0
+//     {
-//     mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
+//         let _4 := 0
+//         mstore(_4, and(calldataload(_4), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/not_applied_function_call_different_arguments.yul

@@ -6,9 +6,11 @@
 // step: fullSimplify
 //
 // {
-//     let _2 := f(1)
+//     {
-//     let _3 := 0
+//         let _2 := f(1)
-//     mstore(_3, sub(f(_3), _2))
+//         let _3 := 0
+//         mstore(_3, sub(f(_3), _2))
+//     }
 //     function f(a) -> b
 //     { }
 // }

test/libyul/yulOptimizerTests/fullSimplify/not_applied_function_call_different_names.yul

@@ -8,7 +8,7 @@
 // step: fullSimplify
 //
 // {
-//     mstore(0, sub(f1(), f2()))
+//     { mstore(0, sub(f1(), f2())) }
 //     function f1() -> a
 //     { }
 //     function f2() -> b

test/libyul/yulOptimizerTests/fullSimplify/not_applied_function_call_equality_not_movable.yul

@@ -8,7 +8,7 @@
 // step: fullSimplify
 //
 // {
-//     mstore(0, sub(f(), f()))
+//     { mstore(0, sub(f(), f())) }
 //     function f() -> a
 //     { mstore(1, 2) }
 // }

test/libyul/yulOptimizerTests/fullSimplify/not_applied_removes_non_constant_and_not_movable.yul

@@ -7,7 +7,9 @@
 // step: fullSimplify
 //
 // {
-//     let _1 := 0
+//     {
-//     pop(create(_1, _1, _1))
+//         let _1 := 0
-//     mstore(_1, 0)
+//         pop(create(_1, _1, _1))
+//         mstore(_1, 0)
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/operations.yul

@@ -23,22 +23,24 @@
 // step: fullSimplify
 //
 // {
-//     mstore(1, 0)
+//     {
-//     mstore(2, 0)
+//         mstore(1, 0)
-//     mstore(3, 0)
+//         mstore(2, 0)
-//     mstore(4, 0)
+//         mstore(3, 0)
-//     mstore(5, 0)
+//         mstore(4, 0)
-//     mstore(6, 0)
+//         mstore(5, 0)
-//     mstore(7, 0)
+//         mstore(6, 0)
-//     mstore(8, 0)
+//         mstore(7, 0)
-//     mstore(9, 0)
+//         mstore(8, 0)
-//     mstore(10, 0)
+//         mstore(9, 0)
-//     mstore(11, 0)
+//         mstore(10, 0)
-//     mstore(12, 0)
+//         mstore(11, 0)
-//     mstore(13, 0)
+//         mstore(12, 0)
-//     mstore(14, 0)
+//         mstore(13, 0)
-//     mstore(15, 0)
+//         mstore(14, 0)
-//     mstore(16, 0)
+//         mstore(15, 0)
-//     mstore(17, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//         mstore(16, 0)
-//     mstore(18, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//         mstore(17, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//         mstore(18, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/reversed.yul

@@ -6,6 +6,8 @@
 // step: fullSimplify
 //
 // {
-//     let _1 := 0
+//     {
-//     mstore(_1, mload(_1))
+//         let _1 := 0
+//         mstore(_1, mload(_1))
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/signextend.yul

@@ -8,6 +8,8 @@
 // step: fullSimplify
 //
 // {
-//     mstore(0, 7)
+//     {
-//     mstore(1, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//         mstore(0, 7)
+//         mstore(1, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
+//     }
 // }

test/libyul/yulOptimizerTests/fullSimplify/smoke.yul

@@ -2,4 +2,4 @@
 // ----
 // step: fullSimplify
 //
-// { }
+// { { } }

test/libyul/yulOptimizerTests/loadResolver/double_mload.yul

@@ -8,6 +8,8 @@
 // step: loadResolver
 //
 // {
-//     let a := mload(calldataload(0))
+//     {
-//     sstore(a, a)
+//         let a := mload(calldataload(0))
+//         sstore(a, a)
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/double_mload_with_other_reassignment.yul

@@ -9,8 +9,10 @@
 // step: loadResolver
 //
 // {
-//     let x := calldataload(0)
+//     {
-//     let a := mload(x)
+//         let x := calldataload(0)
-//     x := 7
+//         let a := mload(x)
-//     sstore(a, mload(x))
+//         x := 7
+//         sstore(a, mload(x))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/double_mload_with_reassignment.yul

@@ -9,8 +9,10 @@
 // step: loadResolver
 //
 // {
-//     let x := calldataload(0)
+//     {
-//     let a := mload(x)
+//         let x := calldataload(0)
-//     a := 7
+//         let a := mload(x)
-//     sstore(a, mload(x))
+//         a := 7
+//         sstore(a, mload(x))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak.yul

@@ -9,8 +9,10 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 10
+//     {
-//     let _2 := 0
+//         let _1 := 10
-//     mstore(_2, _1)
+//         let _2 := 0
-//     sstore(_2, 89717814153306320011181716697424560163256864414616650038987186496166826726056)
+//         mstore(_2, _1)
+//         sstore(_2, 89717814153306320011181716697424560163256864414616650038987186496166826726056)
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_crash.yul

@@ -6,8 +6,10 @@
 // step: loadResolver
 //
 // {
-//     for { }
+//     {
-//     addmod(keccak256(0x0, create(0x0, 0x0, 0x0)), 0x0, 0x0)
+//         for { }
-//     { }
+//         addmod(keccak256(0x0, create(0x0, 0x0, 0x0)), 0x0, 0x0)
-//     { }
+//         { }
+//         { }
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_fail1.yul

@@ -10,9 +10,11 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 30
+//     {
-//     let _2 := 0
+//         let _1 := 30
-//     mstore(_2, _1)
+//         let _2 := 0
-//     if calldataload(_2) { mstore(_2, 20) }
+//         mstore(_2, _1)
-//     sstore(_2, keccak256(_2, 32))
+//         if calldataload(_2) { mstore(_2, 20) }
+//         sstore(_2, keccak256(_2, 32))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_fail2.yul

@@ -9,8 +9,10 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 10
+//     {
-//     mstore(100, _1)
+//         let _1 := 10
-//     mstore(132, 5)
+//         mstore(100, _1)
-//     sstore(0, keccak256(_1, 33))
+//         mstore(132, 5)
+//         sstore(0, keccak256(_1, 33))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_short.yul

@@ -19,13 +19,15 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 10
+//     {
-//     let _2 := 0
+//         let _1 := 10
-//     mstore(_2, _1)
+//         let _2 := 0
-//     sstore(_2, 9948786400348073077032572701554570401043517428989726124163377057770909578447)
+//         mstore(_2, _1)
-//     sstore(1, 110945455955148346822663466543669633859020391897956790847617069135813044810108)
+//         sstore(_2, 9948786400348073077032572701554570401043517428989726124163377057770909578447)
-//     let _13 := 85131057757245807317576516368191972321038229705283732634690444270750521936266
+//         sstore(1, 110945455955148346822663466543669633859020391897956790847617069135813044810108)
-//     let _14 := 2
+//         let _13 := 85131057757245807317576516368191972321038229705283732634690444270750521936266
-//     sstore(_14, _13)
+//         let _14 := 2
-//     sstore(_14, 89477152217924674838424037953991966239322087453347756267410168184682657981552)
+//         sstore(_14, _13)
+//         sstore(_14, 89477152217924674838424037953991966239322087453347756267410168184682657981552)
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_string_literal.yul

@@ -12,11 +12,13 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 50
+//     {
-//     let _2 := "abcdefghijklmn"
+//         let _1 := 50
-//     mstore(_1, _2)
+//         let _2 := "abcdefghijklmn"
-//     let _3 := 51246744213555520563123611275127692828770413530219146609532820042079541949502
+//         mstore(_1, _2)
-//     let _4 := 0
+//         let _3 := 51246744213555520563123611275127692828770413530219146609532820042079541949502
-//     sstore(_4, _3)
+//         let _4 := 0
-//     sstore(_4, add(_2, 1))
+//         sstore(_4, _3)
+//         sstore(_4, add(_2, 1))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_symbolic_memory.yul

@@ -15,8 +15,10 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 0
+//     {
-//     mstore(calldataload(_1), 500)
+//         let _1 := 0
-//     sstore(_1, 92647596584187651892918913434663110448935397770592030057655219009846081465370)
+//         mstore(calldataload(_1), 500)
-//     sstore(1, 110620294328144418057589324861608220015688365608948720310623173341503153578932)
+//         sstore(_1, 92647596584187651892918913434663110448935397770592030057655219009846081465370)
+//         sstore(1, 110620294328144418057589324861608220015688365608948720310623173341503153578932)
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/keccak_with_msize.yul

@@ -11,9 +11,11 @@
 // step: loadResolver
 //
 // {
-//     let _1 := msize()
+//     {
-//     let _2 := 0
+//         let _1 := msize()
-//     sstore(_2, _1)
+//         let _2 := 0
-//     mstore(_2, 10)
+//         sstore(_2, _1)
-//     sstore(1, keccak256(_2, 32))
+//         mstore(_2, 10)
+//         sstore(1, keccak256(_2, 32))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/loop.yul

@@ -8,11 +8,13 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 123213
+//     {
-//     let _2 := 0
+//         let _1 := 123213
-//     sstore(_2, _1)
+//         let _2 := 0
-//     let x := _2
+//         sstore(_2, _1)
-//     let y
+//         let x := _2
-//     for { } lt(x, _1) { x := add(x, 1) }
+//         let y
-//     { y := add(x, y) }
+//         for { } lt(x, _1) { x := add(x, 1) }
+//         { y := add(x, y) }
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/memory_with_different_kinds_of_invalidation.yul

@@ -18,18 +18,20 @@
 // step: loadResolver
 //
 // {
-//     let _1 := 9
+//     {
-//     let _2 := 2
+//         let _1 := 9
-//     mstore(_2, _1)
+//         let _2 := 2
-//     let _4 := _1
+//         mstore(_2, _1)
-//     let _5 := 0
+//         let _4 := _1
-//     sstore(_5, _4)
+//         let _5 := 0
-//     pop(call(_5, _5, _5, _5, _5, _5, _5))
+//         sstore(_5, _4)
-//     sstore(_5, mload(_2))
+//         pop(call(_5, _5, _5, _5, _5, _5, _5))
-//     let _17 := 10
+//         sstore(_5, mload(_2))
-//     mstore(_2, _17)
+//         let _17 := 10
-//     mstore8(calldataload(_5), 4)
+//         mstore(_2, _17)
-//     sstore(_5, mload(_2))
+//         mstore8(calldataload(_5), 4)
-//     mstore(_2, _17)
+//         sstore(_5, mload(_2))
-//     sstore(_5, _17)
+//         mstore(_2, _17)
+//         sstore(_5, _17)
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/memory_with_msize.yul

@@ -9,9 +9,11 @@
 // step: loadResolver
 //
 // {
-//     let _1 := msize()
+//     {
-//     let _3 := calldataload(0)
+//         let _1 := msize()
-//     mstore(_3, _1)
+//         let _3 := calldataload(0)
-//     let t := mload(calldataload(10))
+//         mstore(_3, _1)
-//     sstore(t, mload(_3))
+//         let t := mload(calldataload(10))
+//         sstore(t, mload(_3))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/merge_known_write.yul

@@ -11,12 +11,14 @@
 // step: loadResolver
 //
 // {
-//     let _2 := calldataload(10)
+//     {
-//     let _3 := 0
+//         let _2 := calldataload(10)
-//     let _4 := calldataload(_3)
+//         let _3 := 0
-//     mstore(_4, _2)
+//         let _4 := calldataload(_3)
-//     let _5 := 1
+//         mstore(_4, _2)
-//     if calldataload(_5) { mstore(_4, _5) }
+//         let _5 := 1
-//     let t := mload(_3)
+//         if calldataload(_5) { mstore(_4, _5) }
-//     sstore(t, mload(_4))
+//         let t := mload(_3)
+//         sstore(t, mload(_4))
+//     }
 // }

test/libyul/yulOptimizerTests/loadResolver/merge_known_write_with_distance.yul

@@ -11,10 +11,12 @@
 // step: loadResolver
 //
 // {
-//     let _2 := calldataload(10)
+//     {
-//     let _4 := calldataload(0)
+//         let _2 := calldataload(10)
-//     mstore(_4, _2)
+//         let _4 := calldataload(0)
-//     let _5 := 1
+//         mstore(_4, _2)
-//     if calldataload(_5) { mstore(add(_4, 0x20), _5) }
+//         let _5 := 1
-//     sstore(mload(add(_4, 0x20)), _2)
+//         if calldataload(_5) { mstore(add(_4, 0x20), _5) }
+//         sstore(mload(add(_4, 0x20)), _2)
+//     }
 // }