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

[variant baseline]
public fun signer::address_of($t0|s: &signer): address {
     var $t1: &signer
     var $t2: &address
     var $t3: address
  0: $t1 := move($t0)
  1: $t2 := signer::borrow_address($t1)
  2: $t3 := read_ref($t2)
  3: return $t3
}


[variant baseline]
public native fun signer::borrow_address($t0|s: &signer): &address;


[variant baseline]
fun SmokeTest::arithmetic_ops($t0|a: u64): (u64, u64) {
     var $t1|c: u64
     var $t2: u64
     var $t3: u64
     var $t4: u64
     var $t5: bool
     var $t6: u64
     var $t7: u64
     var $t8: u64
  0: $t2 := 2
  1: $t1 := $t2
  2: $t3 := copy($t1)
  3: $t4 := 2
  4: $t5 := !=($t3, $t4)
  5: if ($t5) goto 6 else goto 9
  6: label L0
  7: $t6 := 42
  8: abort($t6)
  9: label L2
 10: $t7 := move($t1)
 11: $t8 := move($t0)
 12: return ($t7, $t8)
}


[variant baseline]
fun SmokeTest::bool_ops($t0|a: u64, $t1|b: u64): (bool, bool) {
     var $t2|tmp#$2: bool
     var $t3|tmp#$3: bool
     var $t4|c: bool
     var $t5|d: bool
     var $t6: u64
     var $t7: u64
     var $t8: bool
     var $t9: u64
     var $t10: u64
     var $t11: bool
     var $t12: bool
     var $t13: bool
     var $t14: u64
     var $t15: u64
     var $t16: bool
     var $t17: bool
     var $t18: u64
     var $t19: u64
     var $t20: bool
     var $t21: bool
     var $t22: bool
     var $t23: bool
     var $t24: bool
     var $t25: bool
     var $t26: u64
     var $t27: bool
     var $t28: bool
  0: $t6 := copy($t0)
  1: $t7 := copy($t1)
  2: $t8 := >($t6, $t7)
  3: if ($t8) goto 4 else goto 10
  4: label L0
  5: $t9 := copy($t0)
  6: $t10 := copy($t1)
  7: $t11 := >=($t9, $t10)
  8: $t2 := $t11
  9: goto 14
 10: label L2
 11: $t12 := false
 12: $t2 := $t12
 13: goto 14
 14: label L3
 15: $t13 := move($t2)
 16: $t4 := $t13
 17: $t14 := copy($t0)
 18: $t15 := copy($t1)
 19: $t16 := <($t14, $t15)
 20: if ($t16) goto 21 else goto 25
 21: label L4
 22: $t17 := true
 23: $t3 := $t17
 24: goto 31
 25: label L6
 26: $t18 := move($t0)
 27: $t19 := move($t1)
 28: $t20 := <=($t18, $t19)
 29: $t3 := $t20
 30: goto 31
 31: label L7
 32: $t21 := move($t3)
 33: $t5 := $t21
 34: $t22 := copy($t4)
 35: $t23 := copy($t5)
 36: $t24 := !=($t22, $t23)
 37: $t25 := !($t24)
 38: if ($t25) goto 39 else goto 42
 39: label L8
 40: $t26 := 42
 41: abort($t26)
 42: label L10
 43: $t27 := move($t4)
 44: $t28 := move($t5)
 45: return ($t27, $t28)
}


[variant baseline]
fun SmokeTest::borrow_global_mut_test($t0|a: address) {
     var $t1|r: &mut SmokeTest::R
     var $t2|r2: &mut SmokeTest::R
     var $t3: address
     var $t4: &mut SmokeTest::R
     var $t5: &mut SmokeTest::R
     var $t6: address
     var $t7: &mut SmokeTest::R
     var $t8: &mut SmokeTest::R
  0: $t3 := copy($t0)
  1: $t4 := borrow_global<SmokeTest::R>($t3)
  2: $t1 := $t4
  3: $t5 := move($t1)
  4: destroy($t5)
  5: $t6 := move($t0)
  6: $t7 := borrow_global<SmokeTest::R>($t6)
  7: $t2 := $t7
  8: $t8 := move($t2)
  9: destroy($t8)
 10: return ()
}


[variant baseline]
fun SmokeTest::create_resource($t0|sender: &signer) {
     var $t1: &signer
     var $t2: u64
     var $t3: SmokeTest::R
  0: $t1 := move($t0)
  1: $t2 := 1
  2: $t3 := pack SmokeTest::R($t2)
  3: move_to<SmokeTest::R>($t3, $t1)
  4: return ()
}


[variant baseline]
fun SmokeTest::create_resoure_generic($t0|sender: &signer) {
     var $t1: &signer
     var $t2: u64
     var $t3: SmokeTest::G<u64>
  0: $t1 := move($t0)
  1: $t2 := 1
  2: $t3 := pack SmokeTest::G<u64>($t2)
  3: move_to<SmokeTest::G<u64>>($t3, $t1)
  4: return ()
}


[variant baseline]
fun SmokeTest::exists_resource($t0|sender: &signer): bool {
     var $t1: &signer
     var $t2: address
     var $t3: bool
  0: $t1 := move($t0)
  1: $t2 := signer::address_of($t1)
  2: $t3 := exists<SmokeTest::R>($t2)
  3: return $t3
}


[variant baseline]
fun SmokeTest::identity($t0|a: SmokeTest::A, $t1|b: SmokeTest::B, $t2|c: SmokeTest::C): (SmokeTest::A, SmokeTest::B, SmokeTest::C) {
     var $t3: SmokeTest::A
     var $t4: SmokeTest::B
     var $t5: SmokeTest::C
  0: $t3 := move($t0)
  1: $t4 := move($t1)
  2: $t5 := move($t2)
  3: return ($t3, $t4, $t5)
}


[variant baseline]
fun SmokeTest::move_from_addr($t0|a: address) {
     var $t1|r: SmokeTest::R
     var $t2: address
     var $t3: SmokeTest::R
     var $t4: SmokeTest::R
     var $t5: u64
  0: $t2 := move($t0)
  1: $t3 := move_from<SmokeTest::R>($t2)
  2: $t1 := $t3
  3: $t4 := move($t1)
  4: $t5 := unpack SmokeTest::R($t4)
  5: destroy($t5)
  6: return ()
}


[variant baseline]
fun SmokeTest::move_from_addr_to_sender($t0|sender: &signer, $t1|a: address) {
     var $t2|r: SmokeTest::R
     var $t3|x: u64
     var $t4: address
     var $t5: SmokeTest::R
     var $t6: SmokeTest::R
     var $t7: u64
     var $t8: &signer
     var $t9: u64
     var $t10: SmokeTest::R
  0: $t4 := move($t1)
  1: $t5 := move_from<SmokeTest::R>($t4)
  2: $t2 := $t5
  3: $t6 := move($t2)
  4: $t7 := unpack SmokeTest::R($t6)
  5: $t3 := $t7
  6: $t8 := move($t0)
  7: $t9 := move($t3)
  8: $t10 := pack SmokeTest::R($t9)
  9: move_to<SmokeTest::R>($t10, $t8)
 10: return ()
}


[variant baseline]
fun SmokeTest::pack_A($t0|a: address, $t1|va: u64): SmokeTest::A {
     var $t2: address
     var $t3: u64
     var $t4: SmokeTest::A
  0: $t2 := move($t0)
  1: $t3 := move($t1)
  2: $t4 := pack SmokeTest::A($t2, $t3)
  3: return $t4
}


[variant baseline]
fun SmokeTest::pack_B($t0|a: address, $t1|va: u64, $t2|vb: u64): SmokeTest::B {
     var $t3|var_a: SmokeTest::A
     var $t4|var_b: SmokeTest::B
     var $t5: address
     var $t6: u64
     var $t7: SmokeTest::A
     var $t8: u64
     var $t9: SmokeTest::A
     var $t10: SmokeTest::B
     var $t11: SmokeTest::B
  0: $t5 := move($t0)
  1: $t6 := move($t1)
  2: $t7 := pack SmokeTest::A($t5, $t6)
  3: $t3 := $t7
  4: $t8 := move($t2)
  5: $t9 := move($t3)
  6: $t10 := pack SmokeTest::B($t8, $t9)
  7: $t4 := $t10
  8: $t11 := move($t4)
  9: return $t11
}


[variant baseline]
fun SmokeTest::pack_C($t0|a: address, $t1|va: u64, $t2|vb: u64, $t3|vc: u64): SmokeTest::C {
     var $t4|var_a: SmokeTest::A
     var $t5|var_b: SmokeTest::B
     var $t6|var_c: SmokeTest::C
     var $t7: address
     var $t8: u64
     var $t9: SmokeTest::A
     var $t10: u64
     var $t11: SmokeTest::A
     var $t12: SmokeTest::B
     var $t13: u64
     var $t14: SmokeTest::B
     var $t15: SmokeTest::C
     var $t16: SmokeTest::C
  0: $t7 := move($t0)
  1: $t8 := move($t1)
  2: $t9 := pack SmokeTest::A($t7, $t8)
  3: $t4 := $t9
  4: $t10 := move($t2)
  5: $t11 := move($t4)
  6: $t12 := pack SmokeTest::B($t10, $t11)
  7: $t5 := $t12
  8: $t13 := move($t3)
  9: $t14 := move($t5)
 10: $t15 := pack SmokeTest::C($t13, $t14)
 11: $t6 := $t15
 12: $t16 := move($t6)
 13: return $t16
}


[variant baseline]
fun SmokeTest::ref_A($t0|a: address, $t1|b: bool): SmokeTest::A {
     var $t2|tmp#$2: SmokeTest::A
     var $t3|b_val_ref: &u64
     var $t4|b_var: u64
     var $t5|var_a: SmokeTest::A
     var $t6|var_a_ref: &SmokeTest::A
     var $t7: bool
     var $t8: address
     var $t9: u64
     var $t10: SmokeTest::A
     var $t11: address
     var $t12: u64
     var $t13: SmokeTest::A
     var $t14: SmokeTest::A
     var $t15: &SmokeTest::A
     var $t16: &SmokeTest::A
     var $t17: &u64
     var $t18: &u64
     var $t19: u64
     var $t20: u64
     var $t21: u64
     var $t22: bool
     var $t23: u64
     var $t24: SmokeTest::A
  0: $t7 := move($t1)
  1: if ($t7) goto 2 else goto 8
  2: label L0
  3: $t8 := move($t0)
  4: $t9 := 1
  5: $t10 := pack SmokeTest::A($t8, $t9)
  6: $t2 := $t10
  7: goto 14
  8: label L2
  9: $t11 := move($t0)
 10: $t12 := 42
 11: $t13 := pack SmokeTest::A($t11, $t12)
 12: $t2 := $t13
 13: goto 14
 14: label L3
 15: $t14 := move($t2)
 16: $t5 := $t14
 17: $t15 := borrow_local($t5)
 18: $t6 := $t15
 19: $t16 := move($t6)
 20: $t17 := borrow_field<SmokeTest::A>.val($t16)
 21: $t3 := $t17
 22: $t18 := move($t3)
 23: $t19 := read_ref($t18)
 24: $t4 := $t19
 25: $t20 := move($t4)
 26: $t21 := 42
 27: $t22 := !=($t20, $t21)
 28: if ($t22) goto 29 else goto 32
 29: label L4
 30: $t23 := 42
 31: abort($t23)
 32: label L6
 33: $t24 := move($t5)
 34: return $t24
}


[variant baseline]
fun SmokeTest::unpack_A($t0|a: address, $t1|va: u64): (address, u64) {
     var $t2|aa: address
     var $t3|v1: u64
     var $t4|var_a: SmokeTest::A
     var $t5: address
     var $t6: u64
     var $t7: SmokeTest::A
     var $t8: SmokeTest::A
     var $t9: address
     var $t10: u64
     var $t11: address
     var $t12: u64
  0: $t5 := move($t0)
  1: $t6 := move($t1)
  2: $t7 := pack SmokeTest::A($t5, $t6)
  3: $t4 := $t7
  4: $t8 := move($t4)
  5: ($t9, $t10) := unpack SmokeTest::A($t8)
  6: $t3 := $t10
  7: $t2 := $t9
  8: $t11 := move($t2)
  9: $t12 := move($t3)
 10: return ($t11, $t12)
}


[variant baseline]
fun SmokeTest::unpack_B($t0|a: address, $t1|va: u64, $t2|vb: u64): (address, u64, u64) {
     var $t3|aa: address
     var $t4|v1: u64
     var $t5|v2: u64
     var $t6|var_a: SmokeTest::A
     var $t7|var_b: SmokeTest::B
     var $t8: address
     var $t9: u64
     var $t10: SmokeTest::A
     var $t11: u64
     var $t12: SmokeTest::A
     var $t13: SmokeTest::B
     var $t14: SmokeTest::B
     var $t15: u64
     var $t16: SmokeTest::A
     var $t17: address
     var $t18: u64
     var $t19: address
     var $t20: u64
     var $t21: u64
  0: $t8 := move($t0)
  1: $t9 := move($t1)
  2: $t10 := pack SmokeTest::A($t8, $t9)
  3: $t6 := $t10
  4: $t11 := move($t2)
  5: $t12 := move($t6)
  6: $t13 := pack SmokeTest::B($t11, $t12)
  7: $t7 := $t13
  8: $t14 := move($t7)
  9: ($t15, $t16) := unpack SmokeTest::B($t14)
 10: ($t17, $t18) := unpack SmokeTest::A($t16)
 11: $t4 := $t18
 12: $t3 := $t17
 13: $t5 := $t15
 14: $t19 := move($t3)
 15: $t20 := move($t4)
 16: $t21 := move($t5)
 17: return ($t19, $t20, $t21)
}


[variant baseline]
fun SmokeTest::unpack_C($t0|a: address, $t1|va: u64, $t2|vb: u64, $t3|vc: u64): (address, u64, u64, u64) {
     var $t4|aa: address
     var $t5|v1: u64
     var $t6|v2: u64
     var $t7|v3: u64
     var $t8|var_a: SmokeTest::A
     var $t9|var_b: SmokeTest::B
     var $t10|var_c: SmokeTest::C
     var $t11: address
     var $t12: u64
     var $t13: SmokeTest::A
     var $t14: u64
     var $t15: SmokeTest::A
     var $t16: SmokeTest::B
     var $t17: u64
     var $t18: SmokeTest::B
     var $t19: SmokeTest::C
     var $t20: SmokeTest::C
     var $t21: u64
     var $t22: SmokeTest::B
     var $t23: u64
     var $t24: SmokeTest::A
     var $t25: address
     var $t26: u64
     var $t27: address
     var $t28: u64
     var $t29: u64
     var $t30: u64
  0: $t11 := move($t0)
  1: $t12 := move($t1)
  2: $t13 := pack SmokeTest::A($t11, $t12)
  3: $t8 := $t13
  4: $t14 := move($t2)
  5: $t15 := move($t8)
  6: $t16 := pack SmokeTest::B($t14, $t15)
  7: $t9 := $t16
  8: $t17 := move($t3)
  9: $t18 := move($t9)
 10: $t19 := pack SmokeTest::C($t17, $t18)
 11: $t10 := $t19
 12: $t20 := move($t10)
 13: ($t21, $t22) := unpack SmokeTest::C($t20)
 14: ($t23, $t24) := unpack SmokeTest::B($t22)
 15: ($t25, $t26) := unpack SmokeTest::A($t24)
 16: $t5 := $t26
 17: $t4 := $t25
 18: $t6 := $t23
 19: $t7 := $t21
 20: $t27 := move($t4)
 21: $t28 := move($t5)
 22: $t29 := move($t6)
 23: $t30 := move($t7)
 24: return ($t27, $t28, $t29, $t30)
}