--- C.
B0 = EntryBlock()
  v6 = Constant(null)
  v1 = Parameter(this)   # RA: param[0] <- ()
  ParallelMove output(param[0] -> vloc:R0)
  DirectCall Object.(v1)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove input(NullConstant(null) -> R0)
  Return(v6)   # RA: (R0)

--- C.typeParameters
B0 = EntryBlock()
  v9 = Constant(null)
  v1 = Parameter(#functionTypeParameters)   # RA: param[0] <- ()
  v2 = Parameter(this)   # RA: param[1] <- ()
  v3 = Parameter(x)   # RA: param[2] <- ()
  ParallelMove output(param[2] -> vloc:R6, param[1] -> vloc:R0, param[0] -> vloc:R5)
  v20 = LoadInstanceField(C.#typeArguments, v2)   # RA: R2 <- (R0)
  ParallelMove spill(R2 -> stack[0])
  ParallelMove input(vloc:R6 -> R0, vloc:R2 -> R2, NullConstant(null) -> R1, R2 -> R9)
  v10 = TypeTest(v3, v20, v9, List<C.T%>)   # RA: R7 <- (R0, R2, R1) temps: [R8, R3, R4]
  ParallelMove output(R7 -> vloc:R7)
  DirectCall print(v10)   # RA: R0 <- (R7) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(param[0] -> R1, param[2] -> R5)
  ParallelMove input(vloc:R5 -> R0, NullConstant(null) -> R2, vloc:R1 -> R1, R1 -> R6)
  v13 = TypeTest(v3, v9, v1, List<C.typeParameters.U%>)   # RA: R7 <- (R0, R2, R1) temps: [R8, R3, R4]
  ParallelMove output(R7 -> vloc:R7)
  DirectCall print(v13)   # RA: R0 <- (R7) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(param[0] -> R3, param[2] -> R1, stack[0] -> R2)
  ParallelMove input(vloc:R1 -> R0, vloc:R2 -> R2, vloc:R3 -> R1)
  v16 = TypeCast(v3, v20, v1, Map<C.T%, C.typeParameters.U%>)   # RA: R0 <- (R0, R2, R1) temps: [R8, R3, R4]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v16)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove input(NullConstant(null) -> R0)
  Return(v9)   # RA: (R0)

--- test1
B0 = EntryBlock()
  Constant(0)
  v1 = Parameter(a)   # RA: param[0] <- ()
  v2 = Parameter(b)   # RA: param[1] <- ()
  ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0)
  v9 = UnboxInt(v1)   # RA: R0 <- (R0)
  v10 = UnboxInt(v2)   # RA: R1 <- (R1)
  v7 = Comparison int & == 0(v9, v10)   # RA: R0 <- (R0, R1)
  ParallelMove input(vloc:R0 -> R0)
  Return(v7)   # RA: (R0)

--- test2
B0 = EntryBlock() dominates:(B9, B11, B8)
  Constant(0)
  v13 = Constant("yes")
  v25 = Constant("no")
  v28 = Constant(null)
  v1 = Parameter(a)   # RA: param[0] <- ()
  v2 = Parameter(b)   # RA: param[1] <- ()
  ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0)
  v30 = UnboxInt(v1)   # RA: R0 <- (R0)
  v31 = UnboxInt(v2)   # RA: R1 <- (R1)
  v7 = Comparison int & == 0(v30, v31)   # RA: R0 <- (R0, R1)
  ParallelMove spill(R0 -> stack[0])
  Branch(v7, true: B8, false: B9)   # RA: (R0)
B8 = TargetBlock() idom:B0
  DirectCall print(v13)   # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  Goto(B11)
B9 = TargetBlock() idom:B0
  Goto(B11)
B11 = JoinBlock(B9, B8) idom:B0 dominates:(B21, B23, B20)
  ParallelMove output(stack[0] -> R0)
  Branch(v7, true: B20, false: B21)   # RA: (R0)
B20 = TargetBlock() idom:B11
  Goto(B23)
B21 = TargetBlock() idom:B11
  DirectCall print(v25)   # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  Goto(B23)
B23 = JoinBlock(B21, B20) idom:B11
  ParallelMove input(NullConstant(null) -> R0)
  Return(v28)   # RA: (R0)

--- test3
B0 = EntryBlock() dominates:(B11, B13, B10)
  Constant(0)
  v15 = Constant("yes")
  v1 = Parameter(a)   # RA: param[0] <- ()
  v2 = Parameter(b)   # RA: param[1] <- ()
  ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0)
  v20 = UnboxInt(v1)   # RA: R0 <- (R0)
  v21 = UnboxInt(v2)   # RA: R1 <- (R1)
  v7 = Comparison int & == 0(v20, v21)   # RA: R0 <- (R0, R1)
  ParallelMove spill(R0 -> stack[0])
  Branch(v7, true: B10, false: B11)   # RA: (R0)
B10 = TargetBlock() idom:B0
  DirectCall print(v15)   # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  Goto(B13)
B11 = TargetBlock() idom:B0
  Goto(B13)
B13 = JoinBlock(B11, B10) idom:B0
  ParallelMove output(stack[0] -> R0)
  ParallelMove input(vloc:R0 -> R0)
  Return(v7)   # RA: (R0)

--- test4
B0 = EntryBlock() dominates:(B8, B14, B16, B7)
  v19 = Constant(1)
  v30 = Constant(2)
  v33 = Constant(null)
  v1 = Parameter(a)   # RA: param[0] <- ()
  v2 = Parameter(b)   # RA: param[1] <- ()
  v3 = Parameter(c)   # RA: param[2] <- ()
  ParallelMove output(param[2] -> vloc:R2, param[1] -> vloc:R1, param[0] -> vloc:R0)
  v35 = UnboxInt(v1)   # RA: R0 <- (R0)
  v36 = UnboxInt(v2)   # RA: R1 <- (R1)
  v6 = Comparison int >(v35, v36)   # RA: R0 <- (R0, R1)
  ParallelMove spill(R0 -> stack[0])
  Branch(v6, true: B7, false: B8)   # RA: (R0)
B7 = TargetBlock() idom:B0
  Goto(B16)
B8 = TargetBlock() idom:B0 dominates:(B12, B11)
  Branch(v3, true: B11, false: B12)   # RA: (R2)
B11 = TargetBlock() idom:B8
  Goto(B16)
B16 = JoinBlock(B11, B7) idom:B0
  DirectCall print(v19)   # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  Goto(B14)
B12 = TargetBlock() idom:B8
  Goto(B14)
B14 = JoinBlock(B12, B16) idom:B0 dominates:(B26, B28, B25)
  ParallelMove output(stack[0] -> R0)
  Branch(v6, true: B25, false: B26)   # RA: (R0)
B25 = TargetBlock() idom:B14
  DirectCall print(v30)   # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  Goto(B28)
B26 = TargetBlock() idom:B14
  Goto(B28)
B28 = JoinBlock(B26, B25) idom:B14
  ParallelMove input(NullConstant(null) -> R0)
  Return(v33)   # RA: (R0)

--- test5
B0 = EntryBlock() dominates:(B7, B6)
  Constant(32)
  v11 = Constant(1)
  Constant(16)
  Constant(8)
  v23 = Constant(2)
  Constant(257)
  v37 = Constant(3)
  v47 = Constant(4)
  Constant(7)
  v58 = Constant(5)
  v62 = Constant(-1)
  v69 = Constant(UnboxedIntConstant(32))
  v71 = Constant(UnboxedIntConstant(16))
  v72 = Constant(UnboxedIntConstant(8))
  v74 = Constant(UnboxedIntConstant(257))
  v77 = Constant(UnboxedIntConstant(7))
  v1 = Parameter(a)   # RA: param[0] <- ()
  ParallelMove output(param[0] -> vloc:R0)
  v68 = UnboxInt(v1)   # RA: R1 <- (R0)
  CompareAndBranch int & != 0(v68, v69, true: B6, false: B7)   # RA: (R1, -)
B6 = TargetBlock() idom:B0
  ParallelMove input(IntConstant(1) -> R0)
  Return(v11)   # RA: (R0)
B7 = TargetBlock() idom:B0 dominates:(B19, B18)
  v70 = UnboxInt(v1)   # RA: R1 <- (R0)
  v15 = BinaryIntOp &(v70, v71)   # RA: R1 <- (R1, -)
  CompareAndBranch int ==(v15, v72, true: B18, false: B19)   # RA: (R1, -)
B18 = TargetBlock() idom:B7
  ParallelMove input(IntConstant(2) -> R0)
  Return(v23)   # RA: (R0)
B19 = TargetBlock() idom:B7 dominates:(B33, B32)
  v73 = UnboxInt(v1)   # RA: R1 <- (R0)
  v29 = BinaryIntOp &(v73, v74)   # RA: R1 <- (R1, -)
  CompareAndBranch int ==(v29, v74, true: B32, false: B33)   # RA: (R1, -)
B32 = TargetBlock() idom:B19
  ParallelMove input(IntConstant(3) -> R0)
  Return(v37)   # RA: (R0)
B33 = TargetBlock() idom:B19 dominates:(B43, B42)
  v75 = UnboxInt(v1)   # RA: R1 <- (R0)
  CompareAndBranch int & != 0(v75, v72, true: B42, false: B43)   # RA: (R1, -)
B42 = TargetBlock() idom:B33 dominates:(B54, B53)
  v76 = UnboxInt(v1)   # RA: R0 <- (R0)
  v51 = BinaryIntOp &(v76, v77)   # RA: R0 <- (R0, -)
  CompareAndBranch int ==(v51, v77, true: B53, false: B54)   # RA: (R0, -)
B53 = TargetBlock() idom:B42
  ParallelMove input(IntConstant(-1) -> R0)
  Return(v62)   # RA: (R0)
B54 = TargetBlock() idom:B42
  ParallelMove input(IntConstant(5) -> R0)
  Return(v58)   # RA: (R0)
B43 = TargetBlock() idom:B33
  ParallelMove input(IntConstant(4) -> R0)
  Return(v47)   # RA: (R0)

--- listLiterals
B0 = EntryBlock()
  v5 = Constant(<dynamic>)
  v6 = Constant(0)
  v9 = Constant(null)
  v13 = Constant(<int>)
  v14 = Constant(1)
  v15 = Constant(2)
  v16 = Constant(3)
  v19 = Constant(4)
  v20 = Constant(5)
  v21 = Constant(6)
  v22 = Constant(7)
  v23 = Constant(8)
  v24 = Constant(9)
  v1 = Parameter(#functionTypeParameters)   # RA: param[0] <- ()
  v2 = Parameter(x)   # RA: param[1] <- ()
  ParallelMove output(param[1] -> vloc:R0, param[0] -> vloc:R1)
  v7 = DirectCall _GrowableList.(v5, v6)   # RA: R0 <- (-, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v7)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(param[0] -> R1)
  v10 = TypeArguments(v9, v1, <listLiterals.T%>)   # RA: R0 <- (-, R1)
  ParallelMove spill(R0 -> stack[0])
  v11 = DirectCall _GrowableList.(v10, v6)   # RA: R0 <- (R0, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v11)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  v17 = DirectCall _GrowableList._literal3(v13, v14, v15, v16)   # RA: R0 <- (-, -, -, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v17)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  v40 = AllocateList(v24)   # RA: R1 <- (-) temps: [R3, R2, R0]
  ParallelMove input(IntConstant(1) -> vloc:R3)
  SetListElement(v40, v6, v14)   # RA: (R1, -, R3) temps: [R2, R0]
  ParallelMove input(IntConstant(2) -> vloc:R3)
  SetListElement(v40, v14, v15)   # RA: (R1, -, R3) temps: [R2, R0]
  ParallelMove input(IntConstant(3) -> vloc:R0)
  SetListElement(v40, v15, v16)   # RA: (R1, -, R0) temps: [R3, R2]
  ParallelMove input(IntConstant(4) -> vloc:R3)
  SetListElement(v40, v16, v19)   # RA: (R1, -, R3) temps: [R2, R0]
  ParallelMove input(IntConstant(5) -> vloc:R3)
  SetListElement(v40, v19, v20)   # RA: (R1, -, R3) temps: [R2, R0]
  ParallelMove input(IntConstant(6) -> vloc:R2)
  SetListElement(v40, v20, v21)   # RA: (R1, -, R2) temps: [R3, R0]
  ParallelMove input(IntConstant(7) -> vloc:R2)
  SetListElement(v40, v21, v22)   # RA: (R1, -, R2) temps: [R0, R3]
  ParallelMove input(IntConstant(8) -> vloc:R0)
  SetListElement(v40, v22, v23)   # RA: (R1, -, R0) temps: [R2, R3]
  ParallelMove input(IntConstant(9) -> vloc:R0)
  SetListElement(v40, v23, v24)   # RA: (R1, -, R0) temps: [R2, R3]
  v50 = DirectCall _GrowableList._literal(v13, v40)   # RA: R0 <- (-, R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v50)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  v51 = AllocateList(v24)   # RA: R0 <- (-) temps: [R1, R2, R3]
  ParallelMove output(param[1] -> R3)
  SetListElement(v51, v6, v2)   # RA: (R0, -, R3) temps: [R1, R2]
  SetListElement(v51, v14, v2)   # RA: (R0, -, R3) temps: [R1, R2]
  SetListElement(v51, v15, v2)   # RA: (R0, -, R3) temps: [R2, R1]
  SetListElement(v51, v16, v2)   # RA: (R0, -, R3) temps: [R2, R1]
  SetListElement(v51, v19, v2)   # RA: (R0, -, R3) temps: [R2, R1]
  SetListElement(v51, v20, v2)   # RA: (R0, -, R3) temps: [R1, R2]
  SetListElement(v51, v21, v2)   # RA: (R0, -, R3) temps: [R2, R1]
  SetListElement(v51, v22, v2)   # RA: (R0, -, R3) temps: [R2, R1]
  SetListElement(v51, v23, v2)   # RA: (R0, -, R3) temps: [R2, R1]
  ParallelMove output(stack[0] -> R1)
  v61 = DirectCall _GrowableList._literal(v10, v51)   # RA: R0 <- (R1, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v61)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove input(NullConstant(null) -> R0)
  Return(v9)   # RA: (R0)

--- mapLiterals
B0 = EntryBlock()
  v8 = Constant(<dynamic, dynamic>)
  v11 = Constant(null)
  v15 = Constant(<String, String>)
  v16 = Constant("a")
  v17 = Constant("aa")
  v18 = Constant("b")
  v19 = Constant("bb")
  v31 = Constant(InstanceConstant(const List<dynamic>{}))
  v34 = Constant(4)
  v36 = Constant(0)
  v38 = Constant(1)
  v40 = Constant(2)
  v42 = Constant(3)
  v1 = Parameter(#functionTypeParameters)   # RA: param[0] <- ()
  v2 = Parameter(key)   # RA: param[1] <- ()
  v3 = Parameter(value)   # RA: param[2] <- ()
  v4 = Parameter(key2)   # RA: param[3] <- ()
  v5 = Parameter(value2)   # RA: param[4] <- ()
  ParallelMove output(param[4] -> vloc:R3, param[3] -> vloc:R2, param[2] -> vloc:R1, param[1] -> vloc:R0, param[0] -> vloc:R4)
  v32 = DirectCall Map._fromLiteral(v8, v31)   # RA: R0 <- (-, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v32)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(param[0] -> R1)
  v12 = TypeArguments(v11, v1, <mapLiterals.S%, mapLiterals.T%>)   # RA: R0 <- (-, R1)
  ParallelMove spill(R0 -> stack[0])
  v33 = DirectCall Map._fromLiteral(v12, v31)   # RA: R0 <- (R0, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v33)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  v35 = AllocateList(v34)   # RA: R1 <- (-) temps: [R3, R2, R0]
  ParallelMove input(StringConstant("a") -> vloc:R3)
  SetListElement(v35, v36, v16)   # RA: (R1, -, R3) temps: [R2, R0]
  ParallelMove input(StringConstant("aa") -> vloc:R2)
  SetListElement(v35, v38, v17)   # RA: (R1, -, R2) temps: [R0, R3]
  ParallelMove input(StringConstant("b") -> vloc:R3)
  SetListElement(v35, v40, v18)   # RA: (R1, -, R3) temps: [R2, R0]
  ParallelMove input(StringConstant("bb") -> vloc:R0)
  SetListElement(v35, v42, v19)   # RA: (R1, -, R0) temps: [R3, R2]
  v44 = DirectCall Map._fromLiteral(v15, v35)   # RA: R0 <- (-, R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v44)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(param[2] -> R1)
  v25 = ClosureCall(v3)   # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R2)
  v45 = AllocateList(v34)   # RA: R4 <- (-) temps: [R1, R3, R0]
  ParallelMove output(param[1] -> R3)
  SetListElement(v45, v36, v2)   # RA: (R4, -, R3) temps: [R1, R0]
  SetListElement(v45, v38, v25)   # RA: (R4, -, R2) temps: [R1, R0]
  ParallelMove output(param[3] -> R2)
  SetListElement(v45, v40, v4)   # RA: (R4, -, R2) temps: [R1, R0]
  ParallelMove output(param[4] -> R2)
  SetListElement(v45, v42, v5)   # RA: (R4, -, R2) temps: [R1, R0]
  ParallelMove output(stack[0] -> R0)
  v50 = DirectCall Map._fromLiteral(v12, v45)   # RA: R0 <- (R0, R4) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v50)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove input(NullConstant(null) -> R0)
  Return(v11)   # RA: (R0)

--- stringInterpolation
B0 = EntryBlock()
  v7 = Constant("Hey, x=")
  v9 = Constant(", s=")
  v11 = Constant(", o=")
  v15 = Constant(null)
  v18 = Constant(6)
  v20 = Constant(0)
  v22 = Constant(1)
  v24 = Constant(2)
  v26 = Constant(3)
  v28 = Constant(4)
  v30 = Constant(5)
  v1 = Parameter(x)   # RA: param[0] <- ()
  v2 = Parameter(s)   # RA: param[1] <- ()
  v3 = Parameter(o)   # RA: param[2] <- ()
  ParallelMove output(param[2] -> vloc:R2, param[1] -> vloc:R1, param[0] -> vloc:R0)
  v17 = DirectCall _StringBase._interpolateSingle(v3)   # RA: R0 <- (R2) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v17)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  v19 = AllocateList(v18)   # RA: R0 <- (-) temps: [R1, R2, R3]
  ParallelMove input(StringConstant("Hey, x=") -> vloc:R1)
  SetListElement(v19, v20, v7)   # RA: (R0, -, R1) temps: [R2, R3]
  ParallelMove output(param[0] -> R3)
  SetListElement(v19, v22, v1)   # RA: (R0, -, R3) temps: [R1, R2]
  ParallelMove input(StringConstant(", s=") -> vloc:R1)
  SetListElement(v19, v24, v9)   # RA: (R0, -, R1) temps: [R2, R3]
  ParallelMove output(param[1] -> R3)
  SetListElement(v19, v26, v2)   # RA: (R0, -, R3) temps: [R1, R2]
  ParallelMove input(StringConstant(", o=") -> vloc:R1)
  SetListElement(v19, v28, v11)   # RA: (R0, -, R1) temps: [R2, R3]
  ParallelMove output(param[2] -> R3)
  SetListElement(v19, v30, v3)   # RA: (R0, -, R3) temps: [R1, R2]
  v32 = DirectCall _StringBase._interpolate(v19)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove output(R0 -> vloc:R0)
  DirectCall print(v32)   # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30]
  ParallelMove input(NullConstant(null) -> R0)
  Return(v15)   # RA: (R0)

--- main
B0 = EntryBlock()
  v1 = Constant(null)
  ParallelMove input(NullConstant(null) -> R0)
  Return(v1)   # RA: (R0)