============ initial translation from Move ================

[variant baseline]
public fun Test::f1<#0>($t0|x1: #0): Test::A<#0, u64> {
     var $t1: #0
     var $t2: u64
     var $t3: Test::A<#0, u64>
  0: $t1 := move($t0)
  1: $t2 := 10
  2: $t3 := pack Test::A<#0, u64>($t1, $t2)
  3: return $t3
}


[variant baseline]
public fun Test::f2($t0|x: u8): Test::B<u8> {
     var $t1: u8
     var $t2: Test::A<u8, u64>
     var $t3: Test::B<u8>
  0: $t1 := move($t0)
  1: $t2 := Test::f1<u8>($t1)
  2: $t3 := pack Test::B<u8>($t2)
  3: return $t3
}


[variant baseline]
public fun Test::f3<#0>($t0|x1: #0): Test::A<#0, u64> {
     var $t1: #0
     var $t2: u64
     var $t3: Test::A<#0, u64>
  0: $t1 := move($t0)
  1: $t2 := 1
  2: $t3 := pack Test::A<#0, u64>($t1, $t2)
  3: return $t3
}


[variant baseline]
public fun Test::f4<#0>($t0|x1: #0): Test::B<#0> {
     var $t1: #0
     var $t2: Test::A<#0, u64>
     var $t3: Test::B<#0>
  0: $t1 := move($t0)
  1: $t2 := Test::f3<#0>($t1)
  2: $t3 := pack Test::B<#0>($t2)
  3: return $t3
}


[variant baseline]
public fun Test::f5(): Test::B<u128> {
     var $t0: u128
     var $t1: Test::B<u128>
  0: $t0 := 1
  1: $t1 := Test::f4<u128>($t0)
  2: return $t1
}

============ after pipeline `mono_analysis` ================

[variant baseline]
public fun Test::f1<#0>($t0|x1: #0): Test::A<#0, u64> {
     var $t1: u64
     var $t2: Test::A<#0, u64>
  0: $t1 := 10
  1: $t2 := pack Test::A<#0, u64>($t0, $t1)
  2: label L1
  3: return $t2
}


[variant verification]
public fun Test::f1<#0>($t0|x1: #0): Test::A<#0, u64> {
     var $t1: u64
     var $t2: Test::A<#0, u64>
  0: assume WellFormed($t0)
  1: $t1 := 10
  2: $t2 := pack Test::A<#0, u64>($t0, $t1)
  3: label L1
  4: return $t2
}


[variant verification]
public fun Test::f2($t0|x: u8): Test::B<u8> {
     var $t1: Test::A<u8, u64>
     var $t2: num
     var $t3: Test::B<u8>
  0: assume WellFormed($t0)
  1: $t1 := Test::f1<u8>($t0) on_abort goto 5 with $t2
  2: $t3 := pack Test::B<u8>($t1)
  3: label L1
  4: return $t3
  5: label L2
  6: abort($t2)
}


[variant verification]
public fun Test::f3<#0>($t0|x1: #0): Test::A<#0, u64> {
     var $t1: u64
     var $t2: Test::A<#0, u64>
  0: assume WellFormed($t0)
  1: $t1 := 1
  2: $t2 := pack Test::A<#0, u64>($t0, $t1)
  3: label L1
  4: return $t2
}


[variant baseline]
public fun Test::f4<#0>($t0|x1: #0): Test::B<#0> {
     var $t1: Test::A<#0, u64>
     var $t2: bool
     var $t3: num
     var $t4: Test::B<#0>
  0: $t1 := opaque begin: Test::f3<#0>($t0)
  1: havoc[val]($t2)
  2: if ($t2) goto 3 else goto 6
  3: label L4
  4: trace_abort($t3)
  5: goto 12
  6: label L3
  7: assume WellFormed($t1)
  8: $t1 := opaque end: Test::f3<#0>($t0)
  9: $t4 := pack Test::B<#0>($t1)
 10: label L1
 11: return $t4
 12: label L2
 13: abort($t3)
}


[variant verification]
public fun Test::f4<#0>($t0|x1: #0): Test::B<#0> {
     var $t1: Test::A<#0, u64>
     var $t2: bool
     var $t3: num
     var $t4: Test::B<#0>
  0: assume WellFormed($t0)
  1: $t1 := opaque begin: Test::f3<#0>($t0)
  2: havoc[val]($t2)
  3: if ($t2) goto 4 else goto 7
  4: label L4
  5: trace_abort($t3)
  6: goto 13
  7: label L3
  8: assume WellFormed($t1)
  9: $t1 := opaque end: Test::f3<#0>($t0)
 10: $t4 := pack Test::B<#0>($t1)
 11: label L1
 12: return $t4
 13: label L2
 14: abort($t3)
}


[variant verification]
public fun Test::f5(): Test::B<u128> {
     var $t0: u128
     var $t1: Test::B<u128>
     var $t2: num
  0: $t0 := 1
  1: $t1 := Test::f4<u128>($t0) on_abort goto 4 with $t2
  2: label L1
  3: return $t1
  4: label L2
  5: abort($t2)
}



==== mono-analysis result ====

struct Test::A = {
  <u8, u64>
  <u128, u64>
  <#0, u64>
}
struct Test::B = {
  <u8>
  <u128>
  <#0>
}
fun Test::f1 [baseline] = {
  <u8>
}
fun Test::f4 [baseline] = {
  <u128>
}