;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.

;; RUN: wasm-opt --new-wat-parser -all %s -S -o - | filecheck %s

(module $parse
 ;; types

 ;; CHECK:      (type $void (sub (func)))

 ;; CHECK:      (type $1 (func (result i32)))

 ;; CHECK:      (type $ret2 (func (result i32 i32)))
 (type $ret2 (func (result i32 i32)))

 (rec
  ;; CHECK:      (type $pair (struct (field (mut i32)) (field (mut i64))))

  ;; CHECK:      (type $4 (func (param i32 i64)))

  ;; CHECK:      (type $5 (func (result i32 i64)))

  ;; CHECK:      (type $a2 (array (mut f32)))

  ;; CHECK:      (type $a1 (array i64))

  ;; CHECK:      (type $8 (func (param anyref)))

  ;; CHECK:      (type $9 (func (param i32 i64 v128)))

  ;; CHECK:      (rec
  ;; CHECK-NEXT:  (type $s0 (struct ))
  (type $s0 (struct))
  ;; CHECK:       (type $s1 (struct ))
  (type $s1 (struct (field)))
 )

 (rec)

 ;; CHECK:      (type $12 (func))

 ;; CHECK:      (type $packed-i8 (array (mut i8)))

 ;; CHECK:      (type $many (sub (func (param i32 i64 f32 f64) (result anyref (ref func)))))

 ;; CHECK:      (type $15 (func (param i32)))

 ;; CHECK:      (type $a0 (array i32))

 ;; CHECK:      (type $17 (func (param i32 i32 i32)))

 ;; CHECK:      (type $18 (func (param v128 i32) (result v128)))

 ;; CHECK:      (type $packed-i16 (array (mut i16)))

 ;; CHECK:      (type $any-array (array (mut anyref)))

 ;; CHECK:      (type $21 (func (param stringref)))

 ;; CHECK:      (type $22 (func (param stringref stringref) (result i32)))

 ;; CHECK:      (type $23 (func (param i32 i64) (result f32)))

 ;; CHECK:      (type $24 (func (param i64 v128) (result v128)))

 ;; CHECK:      (type $25 (func (param i64 v128)))

 ;; CHECK:      (type $26 (func (param i32 i32)))

 ;; CHECK:      (type $27 (func (param i32 i32 f64 f64)))

 ;; CHECK:      (type $28 (func (param i64)))

 ;; CHECK:      (type $29 (func (param v128) (result i32)))

 ;; CHECK:      (type $30 (func (param v128 v128) (result v128)))

 ;; CHECK:      (type $31 (func (param v128 v128 v128) (result v128)))

 ;; CHECK:      (type $32 (func (param i32 i32 i64 i64)))

 ;; CHECK:      (type $33 (func (param i32) (result i32)))

 ;; CHECK:      (type $34 (func (param i32 i64) (result i32 i64)))

 ;; CHECK:      (type $35 (func (param i64) (result i32 i64)))

 ;; CHECK:      (type $36 (func (param i32) (result i32 i64)))

 ;; CHECK:      (type $37 (func (param anyref) (result i32)))

 ;; CHECK:      (type $38 (func (param eqref eqref) (result i32)))

 ;; CHECK:      (type $39 (func (param i32) (result i31ref)))

 ;; CHECK:      (type $40 (func (param i31ref)))

 ;; CHECK:      (type $41 (func (param i32 i64) (result (ref $pair))))

 ;; CHECK:      (type $42 (func (result (ref $pair))))

 ;; CHECK:      (type $43 (func (param (ref $pair)) (result i32)))

 ;; CHECK:      (type $44 (func (param (ref $pair)) (result i64)))

 ;; CHECK:      (type $45 (func (param (ref $pair) i32)))

 ;; CHECK:      (type $46 (func (param (ref $pair) i64)))

 ;; CHECK:      (type $47 (func (param i64 i32) (result (ref $a1))))

 ;; CHECK:      (type $48 (func (param i32) (result (ref $a1))))

 ;; CHECK:      (type $49 (func (param i32 i32) (result (ref $a1))))

 ;; CHECK:      (type $50 (func (param (ref $a1) i32) (result i64)))

 ;; CHECK:      (type $51 (func (param (ref $packed-i8) i32) (result i32)))

 ;; CHECK:      (type $52 (func (param (ref $packed-i16) i32) (result i32)))

 ;; CHECK:      (type $53 (func (param (ref $a2) i32 f32)))

 ;; CHECK:      (type $54 (func (param arrayref) (result i32)))

 ;; CHECK:      (type $55 (func (param (ref $a2) i32 (ref $a2) i32 i32)))

 ;; CHECK:      (type $56 (func (param (ref $a2) i32 f32 i32)))

 ;; CHECK:      (type $57 (func (param (ref $a2) i32 i32 i32)))

 ;; CHECK:      (type $58 (func (param (ref $any-array) i32 i32 i32)))

 ;; CHECK:      (type $59 (func (param externref)))

 ;; CHECK:      (type $60 (func (param i32 i32) (result stringref)))

 ;; CHECK:      (type $61 (func (param (ref $packed-i8) i32 i32) (result stringref)))

 ;; CHECK:      (type $62 (func (param i32) (result stringref)))

 ;; CHECK:      (type $63 (func (result (ref string))))

 ;; CHECK:      (type $64 (func (param stringref) (result i32)))

 ;; CHECK:      (type $65 (func (param stringview_wtf16) (result i32)))

 ;; CHECK:      (type $66 (func (param stringref (ref $packed-i8) i32) (result i32)))

 ;; CHECK:      (type $67 (func (param stringref stringref) (result (ref string))))

 ;; CHECK:      (type $68 (func (param stringref) (result stringview_wtf8)))

 ;; CHECK:      (type $69 (func (param stringref) (result (ref stringview_wtf16))))

 ;; CHECK:      (type $70 (func (param stringref) (result stringview_iter)))

 ;; CHECK:      (type $71 (func (param (ref stringview_wtf8) i32 i32) (result i32)))

 ;; CHECK:      (type $72 (func (param stringview_wtf16 i32) (result i32)))

 ;; CHECK:      (type $73 (func (param stringview_iter) (result i32)))

 ;; CHECK:      (type $74 (func (param stringview_iter i32) (result i32)))

 ;; CHECK:      (type $75 (func (param (ref stringview_iter) i32) (result i32)))

 ;; CHECK:      (type $76 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))

 ;; CHECK:      (type $77 (func (param stringview_iter i32) (result (ref string))))

 ;; CHECK:      (type $s2 (struct (field i32)))
 (type $s2 (struct i32))
 ;; CHECK:      (type $s3 (struct (field i64)))
 (type $s3 (struct (field i64)))
 ;; CHECK:      (type $s4 (struct (field $x f32)))
 (type $s4 (struct (field $x f32)))
 ;; CHECK:      (type $s5 (struct (field i32) (field i64)))
 (type $s5 (struct i32 i64))
 ;; CHECK:      (type $s6 (struct (field i64) (field f32)))
 (type $s6 (struct (field i64 f32)))
 ;; CHECK:      (type $s7 (struct (field $x f32) (field $y f64)))
 (type $s7 (struct (field $x f32) (field $y f64)))
 ;; CHECK:      (type $s8 (struct (field i32) (field i64) (field $z f32) (field f64) (field (mut i32))))
 (type $s8 (struct i32 (field) i64 (field $z f32) (field f64 (mut i32))))

 (type $a0 (array i32))
 (type $a1 (array (field i64)))
 (type $a2 (array (mut f32)))
 ;; CHECK:      (type $a3 (array (mut f64)))
 (type $a3 (array (field $x (mut f64))))

 (type $pair (struct (mut i32) (mut i64)))

 (type $packed-i8 (array (mut i8)))

 (type $packed-i16 (array (mut i16)))

 (type $any-array (array (mut anyref)))

 (rec
   (type $void (sub (func)))
 )

 ;; CHECK:      (type $subvoid (sub final $void (func)))
 (type $subvoid (sub final $void (func)))

 (type $many (sub (func (param $x i32) (param i64 f32) (param) (param $y f64)
                             (result anyref (ref func)))))

 ;; CHECK:      (type $submany (sub final $many (func (param i32 i64 f32 f64) (result anyref (ref func)))))
 (type $submany (sub final $many (func (param i32 i64 f32 f64) (result anyref (ref func)))))

 ;; imported memories
 (memory (export "mem") (export "mem2") (import "" "mem") 0)
 ;; CHECK:      (type $88 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany))))

 ;; CHECK:      (import "" "mem" (memory $mimport$0 0))

 ;; CHECK:      (import "mod" "imported-m" (memory $m-imported 1 2 shared))
 (import "mod" "imported-m" (memory $m-imported 1 2 shared))

 ;; imported tables
 (table (export "tab") (export "tab2") (import "" "tab") 0 funcref)
 (import "mod" "imported-tab" (table 2 3 externref))

 ;; imported globals
 (global $g1 (export "g1") (export "g1.1") (import "mod" "g1") i32)
 (global $g2 (import "mod" "g2") (mut i64))
 (global (import "" "g3") (ref 0))
 (global (import "mod" "") (ref null $many))
 ;; CHECK:      (import "" "tab" (table $timport$0 0 funcref))

 ;; CHECK:      (import "mod" "imported-tab" (table $timport$1 2 3 externref))

 ;; CHECK:      (import "mod" "g1" (global $g1 i32))

 ;; CHECK:      (import "mod" "g2" (global $g2 (mut i64)))

 ;; CHECK:      (import "" "g3" (global $gimport$0 (ref $ret2)))

 ;; CHECK:      (import "mod" "" (global $gimport$1 (ref null $many)))

 ;; CHECK:      (import "mod" "imported-g" (global $g-imported (mut i32)))
 (import "mod" "imported-g" (global $g-imported (mut i32)))

 ;; imported functions
 (func (export "f5.0") (export "f5.1") (import "mod" "f5"))
 (import "mod" "imported-f" (func (param) (result)))

 ;; imported tags
 (tag $imported (export "t0.0") (export "t0.1") (import "mod" "t0") (param i32 i64))
 (tag (import "mod" "t1"))
 (import "mod" "imported-tag" (tag (param) (result)))

 ;; globals
 (global (mut i32) i32.const 0)

 ;; CHECK:      (import "mod" "f5" (func $fimport$0 (type $void)))

 ;; CHECK:      (import "mod" "imported-f" (func $fimport$1 (type $void)))

 ;; CHECK:      (import "mod" "t0" (tag $imported (param i32 i64)))

 ;; CHECK:      (import "mod" "t1" (tag $timport$0))

 ;; CHECK:      (import "mod" "imported-tag" (tag $timport$1))

 ;; CHECK:      (global $2 (mut i32) (i32.const 0))

 ;; CHECK:      (global $i32 i32 (i32.const 42))
 (global $i32 i32 i32.const 42)

 ;; memories
 ;; CHECK:      (memory $mem 1 1 shared)
 (memory $mem 1 1 shared)
 (memory 0 1 shared)
 ;; CHECK:      (memory $1 0 1 shared)

 ;; CHECK:      (memory $mem-i32 0 1)
 (memory $mem-i32 i32 0 1)

 ;; CHECK:      (memory $mem-i64 i64 2)
 (memory $mem-i64 i64 2)

 ;; CHECK:      (memory $mem-init 1 1)
 (memory $mem-init (data "hello inline data"))

 ;; data segments
 (data "hello world")
 ;; CHECK:      (data $implicit-data (memory $mem-init) (i32.const 0) "hello inline data")

 ;; CHECK:      (data $0 "hello world")

 ;; CHECK:      (data $passive "hello again")
 (data $passive "hello" " " "again")

 ;; CHECK:      (data $active (i32.const 0) "active hello")
 (data $active (offset i32.const 0) "active hello" "" "")

 ;; CHECK:      (data $active2 (i32.const 1) "active again!")
 (data $active2 (offset (i32.const 1)) "" "active again" "!")

 ;; CHECK:      (data $active3 (memory $mem) (i32.const 42) "active abbreviated")
 (data $active3 (memory $mem) (i32.const 42) "" "active abbreviated" "")

 ;; CHECK:      (data $active4 (memory $mem-i32) (i32.const 16) "")
 (data $active4 (memory $mem-i32) (i32.const 16) "")

 (data (memory 5) (offset i64.const 0) "64-bit")

 ;; tables
 ;; CHECK:      (data $1 (memory $mem-i64) (i64.const 0) "64-bit")

 ;; CHECK:      (table $funcs 1 2 funcref)
 (table $funcs 1 2 (ref null func))

 ;; CHECK:      (table $table-any 3 3 anyref)
 (table $table-any anyref (elem (item i32.const 0 ref.i31) (ref.null any) (item (ref.i31 (i32.const 0)))))

 ;; elems
 ;; CHECK:      (elem $implicit-elem (table $table-any) (i32.const 0) anyref (ref.i31
 ;; CHECK-NEXT:  (i32.const 0)
 ;; CHECK-NEXT: ) (ref.null none) (ref.i31
 ;; CHECK-NEXT:  (i32.const 0)
 ;; CHECK-NEXT: ))

 ;; CHECK:      (elem $implicit-table (table $timport$0) (i32.const 0) funcref (ref.null nofunc) (ref.null nofunc) (ref.null nofunc))
 (elem $implicit-table (offset i32.const 0) funcref (ref.null func) (item ref.null func) (item (ref.null func)))

 ;; CHECK:      (elem $implicit-table-2 (table $timport$0) (i32.const 1) func)
 (elem $implicit-table-2 (i32.const 1) funcref)

 ;; CHECK:      (elem $implicit-table-indices (table $timport$0) (i32.const 2) func $fimport$0 $fimport$1 $2)
 (elem $implicit-table-indices (offset (i32.const 2)) func 0 1 2)

 ;; CHECK:      (elem $implicit-table-legacy-indices (table $timport$0) (i32.const 3) func $fimport$0 $fimport$1 $2 $f1)
 (elem $implicit-table-legacy-indices (i32.const 3) 0 1 2 3)

 ;; CHECK:      (elem $explicit-table (table $timport$0) (i32.const 0) funcref (ref.null nofunc))
 (elem $explicit-table (table 0) (offset (i32.const 0)) funcref (item ref.null func))

 ;; CHECK:      (elem $explicit-table-named (table $table-any) (i32.const 1) anyref)
 (elem $explicit-table-named (table $table-any) (i32.const 1) anyref)

 ;; CHECK:      (elem $passive (ref null $s0) (struct.new_default $s0) (struct.new_default $s0))
 (elem $passive (ref null $s0) (item struct.new $s0) (struct.new $s0))

 ;; CHECK:      (elem $passive-2 anyref (struct.new_default $s0) (struct.new_default $s0))
 (elem $passive-2 anyref (item struct.new $s0) (struct.new $s0))

 ;; CHECK:      (elem declare func $ref-func $ref-is-null $table-fill $table-grow $table-set)
 (elem declare func 0 1 2 3)

 (elem $declare-2 declare funcref (item ref.func 0) (ref.func 1) (item (ref.func 2)))

 ;; tags
 (tag)

 ;; CHECK:      (tag $2)

 ;; CHECK:      (tag $empty)
 (tag $empty)

 ;; CHECK:      (tag $tag-i32 (param i32))
 (tag $tag-i32 (param $x i32))

 ;; CHECK:      (tag $tag-pair (param i32 i64))
 (tag $tag-pair (param i32 i64))

 ;; explicit exports
 (export "exported-func" (func 0))
 ;; CHECK:      (export "mem" (memory $mimport$0))

 ;; CHECK:      (export "mem2" (memory $mimport$0))

 ;; CHECK:      (export "tab" (table $timport$0))

 ;; CHECK:      (export "tab2" (table $timport$0))

 ;; CHECK:      (export "g1" (global $g1))

 ;; CHECK:      (export "g1.1" (global $g1))

 ;; CHECK:      (export "f5.0" (func $fimport$0))

 ;; CHECK:      (export "f5.1" (func $fimport$0))

 ;; CHECK:      (export "t0.0" (tag $imported))

 ;; CHECK:      (export "t0.1" (tag $imported))

 ;; CHECK:      (export "exported-func" (func $fimport$0))

 ;; CHECK:      (export "exported-table" (table $funcs))
 (export "exported-table" (table $funcs))
 (export "exported-memory" (memory 0))
 ;; CHECK:      (export "exported-memory" (memory $mimport$0))

 ;; CHECK:      (export "exported-global" (global $g1))
 (export "exported-global" (global $g1))
 (export "exported-tag" (tag 0))

 ;; functions
 (func)

 ;; CHECK:      (export "exported-tag" (tag $imported))

 ;; CHECK:      (func $2 (type $void)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )

 ;; CHECK:      (func $f1 (type $15) (param $0 i32)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $f1 (param i32))
 ;; CHECK:      (func $f2 (type $15) (param $x i32)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $f2 (param $x i32))
 ;; CHECK:      (func $f3 (type $1) (result i32)
 ;; CHECK-NEXT:  (i32.const 0)
 ;; CHECK-NEXT: )
 (func $f3 (result i32)
  i32.const 0
 )
 ;; CHECK:      (func $f4 (type $void)
 ;; CHECK-NEXT:  (local $0 i32)
 ;; CHECK-NEXT:  (local $1 i64)
 ;; CHECK-NEXT:  (local $l f32)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $f4 (type 18) (local i32 i64) (local $l f32))

 ;; CHECK:      (func $nop-skate (type $void)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $nop-skate
  nop
  nop
  unreachable
  nop
  nop
 )

 ;; CHECK:      (func $nop-ski (type $void)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $nop-ski
  (unreachable
   (nop
    (nop)
    (nop)
    (nop
     (nop)
    )
   )
   (nop)
  )
  (nop)
 )

 ;; CHECK:      (func $nop-sled (type $void)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $nop-sled
  nop
  (nop
   (nop
    (unreachable)
   )
  )
  nop
  (unreachable)
  nop
 )

 ;; CHECK:      (func $add (type $1) (result i32)
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add (result i32)
  i32.const 1
  i32.const 2
  i32.add
 )

 ;; CHECK:      (func $add-folded (type $1) (result i32)
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-folded (result i32)
  (i32.add
   (i32.const 1)
   (i32.const 2)
  )
 )

 ;; CHECK:      (func $add-stacky (type $1) (result i32)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (local.set $scratch
 ;; CHECK-NEXT:     (i32.const 1)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (local.get $scratch)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-stacky (result i32)
  i32.const 1
  nop
  i32.const 2
  i32.add
 )

 ;; CHECK:      (func $add-stacky-2 (type $1) (result i32)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (local.set $scratch
 ;; CHECK-NEXT:     (i32.const 2)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (local.get $scratch)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-stacky-2 (result i32)
  i32.const 1
  i32.const 2
  nop
  i32.add
 )

 ;; CHECK:      (func $add-stacky-3 (type $1) (result i32)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (local.set $scratch
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (local.get $scratch)
 ;; CHECK-NEXT: )
 (func $add-stacky-3 (result i32)
  i32.const 1
  i32.const 2
  i32.add
  nop
 )

 ;; CHECK:      (func $add-stacky-4 (type $1) (result i32)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (local $scratch_1 i32)
 ;; CHECK-NEXT:  (local $scratch_2 i32)
 ;; CHECK-NEXT:  (local.set $scratch_2
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (block (result i32)
 ;; CHECK-NEXT:     (local.set $scratch_1
 ;; CHECK-NEXT:      (i32.const 1)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:     (local.get $scratch_1)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (block (result i32)
 ;; CHECK-NEXT:     (local.set $scratch
 ;; CHECK-NEXT:      (i32.const 2)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:     (local.get $scratch)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (local.get $scratch_2)
 ;; CHECK-NEXT: )
 (func $add-stacky-4 (result i32)
  i32.const 1
  nop
  i32.const 2
  nop
  i32.add
  nop
 )

 ;; CHECK:      (func $add-unreachable (type $1) (result i32)
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-unreachable (result i32)
  unreachable
  i32.const 1
  i32.add
 )

 ;; CHECK:      (func $add-unreachable-2 (type $1) (result i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-unreachable-2 (result i32)
  i32.const 1
  unreachable
  i32.add
 )

 ;; CHECK:      (func $add-unreachable-3 (type $1) (result i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT: )
 (func $add-unreachable-3 (result i32)
  i32.const 1
  i32.const 2
  unreachable
 )

 ;; CHECK:      (func $add-twice (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (tuple.make 2
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 3)
 ;; CHECK-NEXT:    (i32.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-twice (type $ret2)
  i32.const 1
  i32.const 2
  i32.add
  i32.const 3
  i32.const 4
  i32.add
 )

 ;; CHECK:      (func $add-twice-stacky (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (tuple.make 2
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (local.set $scratch
 ;; CHECK-NEXT:     (i32.add
 ;; CHECK-NEXT:      (i32.const 1)
 ;; CHECK-NEXT:      (i32.const 2)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (local.get $scratch)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 3)
 ;; CHECK-NEXT:    (i32.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-twice-stacky (type $ret2)
  i32.const 1
  i32.const 2
  i32.add
  nop
  i32.const 3
  i32.const 4
  i32.add
 )

 ;; CHECK:      (func $add-twice-stacky-2 (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (tuple.make 2
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (local.set $scratch
 ;; CHECK-NEXT:     (i32.add
 ;; CHECK-NEXT:      (i32.const 3)
 ;; CHECK-NEXT:      (i32.const 4)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (local.get $scratch)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $add-twice-stacky-2 (type $ret2)
  i32.const 1
  i32.const 2
  i32.add
  i32.const 3
  i32.const 4
  i32.add
  nop
 )

 ;; CHECK:      (func $add-twice-unreachable (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (i32.add
 ;; CHECK-NEXT:   (unreachable)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 3)
 ;; CHECK-NEXT:    (i32.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT: )
 (func $add-twice-unreachable (type $ret2)
  unreachable
  i32.const 2
  i32.add
  i32.const 3
  i32.const 4
  i32.add
 )

 ;; CHECK:      (func $add-twice-unreachable-2 (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 3)
 ;; CHECK-NEXT:    (i32.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT: )
 (func $add-twice-unreachable-2 (type $ret2)
  i32.const 1
  i32.const 2
  i32.add
  unreachable
  i32.const 3
  i32.const 4
  i32.add
 )

 ;; CHECK:      (func $add-twice-unreachable-3 (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (i32.const 3)
 ;; CHECK-NEXT:    (i32.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT: )
 (func $add-twice-unreachable-3 (type $ret2)
  i32.const 1
  i32.const 2
  i32.add
  i32.const 3
  i32.const 4
  i32.add
  unreachable
 )

 ;; CHECK:      (func $big-stack (type $void)
 ;; CHECK-NEXT:  (local $scratch f64)
 ;; CHECK-NEXT:  (local $scratch_1 i64)
 ;; CHECK-NEXT:  (local $scratch_2 f32)
 ;; CHECK-NEXT:  (local $scratch_3 i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (local.set $scratch_3
 ;; CHECK-NEXT:     (i32.const 0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (block (result f32)
 ;; CHECK-NEXT:      (local.set $scratch_2
 ;; CHECK-NEXT:       (f32.const 1)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (drop
 ;; CHECK-NEXT:       (block (result i64)
 ;; CHECK-NEXT:        (local.set $scratch_1
 ;; CHECK-NEXT:         (i64.const 2)
 ;; CHECK-NEXT:        )
 ;; CHECK-NEXT:        (drop
 ;; CHECK-NEXT:         (block (result f64)
 ;; CHECK-NEXT:          (local.set $scratch
 ;; CHECK-NEXT:           (f64.const 3)
 ;; CHECK-NEXT:          )
 ;; CHECK-NEXT:          (drop
 ;; CHECK-NEXT:           (ref.null none)
 ;; CHECK-NEXT:          )
 ;; CHECK-NEXT:          (local.get $scratch)
 ;; CHECK-NEXT:         )
 ;; CHECK-NEXT:        )
 ;; CHECK-NEXT:        (local.get $scratch_1)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (local.get $scratch_2)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (local.get $scratch_3)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $big-stack
  i32.const 0
  f32.const 1
  i64.const 2
  f64.const 3
  ref.null any
  drop
  drop
  drop
  drop
  drop
 )

 ;; CHECK:      (func $locals (type $26) (param $0 i32) (param $x i32)
 ;; CHECK-NEXT:  (local $2 i32)
 ;; CHECK-NEXT:  (local $y i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.get $y)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (local.set $x
 ;; CHECK-NEXT:   (local.get $x)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.tee $y
 ;; CHECK-NEXT:    (local.get $y)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $locals (param i32) (param $x i32)
  (local i32)
  (local $y i32)
  local.get 0
  drop
  local.get 1
  drop
  local.get 2
  drop
  local.get 3
  drop
  local.get $x
  local.set 1
  local.get $y
  local.tee 3
  drop
 )

 ;; CHECK:      (func $block (type $void)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $block
  nop
  block $l (type $void)
   nop
   nop
   nop
  end $l
 )

 ;; CHECK:      (func $block-folded (type $void)
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (tuple.drop 2
 ;; CHECK-NEXT:   (block $l (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (unreachable)
 ;; CHECK-NEXT: )
 (func $block-folded
  nop
  (block $l (result i32) (result) (result i32)
   nop
   nop
   unreachable
  )
  unreachable
 )

 ;; CHECK:      (func $block-mix (type $void)
 ;; CHECK-NEXT:  (local $scratch i32)
 ;; CHECK-NEXT:  (local $scratch_1 (i32 i32))
 ;; CHECK-NEXT:  (local $scratch_2 i32)
 ;; CHECK-NEXT:  (block $0
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (block (result i32)
 ;; CHECK-NEXT:     (local.set $scratch_2
 ;; CHECK-NEXT:      (tuple.extract 2 0
 ;; CHECK-NEXT:       (local.tee $scratch_1
 ;; CHECK-NEXT:        (block $1 (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:         (tuple.make 2
 ;; CHECK-NEXT:          (block $2 (result i32)
 ;; CHECK-NEXT:           (local.set $scratch
 ;; CHECK-NEXT:            (block $3 (result i32)
 ;; CHECK-NEXT:             (i32.const 0)
 ;; CHECK-NEXT:            )
 ;; CHECK-NEXT:           )
 ;; CHECK-NEXT:           (nop)
 ;; CHECK-NEXT:           (local.get $scratch)
 ;; CHECK-NEXT:          )
 ;; CHECK-NEXT:          (i32.const 1)
 ;; CHECK-NEXT:         )
 ;; CHECK-NEXT:        )
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:     (drop
 ;; CHECK-NEXT:      (tuple.extract 2 1
 ;; CHECK-NEXT:       (local.get $scratch_1)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:     (local.get $scratch_2)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $block-mix
  (block $0
   block $1 (type $ret2)
    (block $2 (result i32)
     block $3 (result i32)
      i32.const 0
     end
     nop
    )
    i32.const 1
   end $1
   drop
   drop
  )
  nop
 )


 ;; CHECK:      (func $multivalue-nested (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:  (local $scratch (i32 i32))
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (local.set $scratch
 ;; CHECK-NEXT:   (block (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:    (block (type $ret2) (result i32 i32)
 ;; CHECK-NEXT:     (tuple.make 2
 ;; CHECK-NEXT:      (i32.const 0)
 ;; CHECK-NEXT:      (i32.const 1)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT:  (local.get $scratch)
 ;; CHECK-NEXT: )
 (func $multivalue-nested (type $ret2)
  block (type $ret2)
   nop
   block (type $ret2)
    block (type $ret2)
     i32.const 0
     i32.const 1
    end
   end
   nop
  end
 )

 ;; CHECK:      (func $if-else (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else
  i32.const 0
  if
   nop
  else
   nop
  end
 )

 ;; CHECK:      (func $if-else-empty (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-empty
  i32.const 0
  if
  else
  end
 )

 ;; CHECK:      (func $if-else-many (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (block
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (block
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-many
  i32.const 0
  if
   nop
   nop
  else
   nop
   nop
  end
 )

 ;; CHECK:      (func $if-else-single-nested (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (f32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (f64.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-single-nested
  i32.const 0
  if
   f32.const 1
   drop
  else
   f64.const 2
   drop
  end
 )

 ;; CHECK:      (func $if-else-folded-body (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (f32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (f32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-body
  i32.const 0
  if
   (drop
    (f32.const 1)
   )
  else
   (drop
    (f32.const 2)
   )
  end
 )

 ;; CHECK:      (func $if-else-labeled (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (if
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-labeled
  i32.const 0
  if $l
   nop
  else $l
   nop
  end $l
 )

 ;; CHECK:      (func $if-no-else (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-no-else
  i32.const 0
  if
   nop
  end
 )

 ;; CHECK:      (func $if-else-result (type $1) (result i32)
 ;; CHECK-NEXT:  (if (result i32)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-result (result i32)
  i32.const 0
  if (result i32)
   i32.const 1
  else
   i32.const 2
  end
 )

 ;; CHECK:      (func $if-else-labeled-result (type $1) (result i32)
 ;; CHECK-NEXT:  (block $l (result i32)
 ;; CHECK-NEXT:   (if (result i32)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-labeled-result (result i32)
  i32.const 0
  if $l (result i32)
   i32.const 1
  else
   i32.const 2
  end
 )

 ;; CHECK:      (func $if-else-folded (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded
  (if
   (i32.const 0)
   (then
    nop
   )
   (else
    nop
   )
  )
 )

 ;; CHECK:      (func $if-else-folded-empty (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-empty
  (if
   (i32.const 0)
   (then)
   (else)
  )
 )

 ;; CHECK:      (func $if-else-folded-many (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (block
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (block
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-many
  (if
   (i32.const 0)
   (then
    nop
    nop
   )
   (else
    nop
    nop
   )
  )
 )

 ;; CHECK:      (func $if-else-folded-single-nested (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.eqz
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-single-nested
  (if
   (i32.eqz
    (i32.const 0)
   )
   (then
    (drop
     (i32.const 1)
    )
   )
   (else
    (drop
     (i32.const 2)
    )
   )
  )
 )

 ;; CHECK:      (func $if-else-folded-labeled (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (if
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-labeled
  (if $l
   (i32.const 0)
   (then
    nop
   )
   (else
    nop
   )
  )
 )

 ;; CHECK:      (func $if-no-else-folded (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-no-else-folded
  (if
   (i32.const 0)
   (then
    nop
   )
  )
 )

 ;; CHECK:      (func $if-else-folded-result (type $1) (result i32)
 ;; CHECK-NEXT:  (if (result i32)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-result (result i32)
  (if (result i32)
   (i32.const 0)
   (then
    i32.const 1
   )
   (else
    i32.const 2
   )
  )
 )

 ;; CHECK:      (func $if-else-folded-labeled-result (type $1) (result i32)
 ;; CHECK-NEXT:  (block $l (result i32)
 ;; CHECK-NEXT:   (if (result i32)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-folded-labeled-result (result i32)
  (if $l (result i32)
   (i32.const 0)
   (then
    i32.const 1
   )
   (else
    i32.const 2
   )
  )
 )

;; CHECK:      (func $if-else-atypical-condition (type $void)
;; CHECK-NEXT:  (if
;; CHECK-NEXT:   (i32.const 0)
;; CHECK-NEXT:   (nop)
;; CHECK-NEXT:   (nop)
;; CHECK-NEXT:  )
;; CHECK-NEXT:  (if
;; CHECK-NEXT:   (i32.eqz
;; CHECK-NEXT:    (i32.const 0)
;; CHECK-NEXT:   )
;; CHECK-NEXT:   (nop)
;; CHECK-NEXT:   (nop)
;; CHECK-NEXT:  )
;; CHECK-NEXT: )
(func $if-else-atypical-condition
 i32.const 0
 (if (then) (else))
 (if (i32.const 0) (i32.eqz) (then) (else))
)

 ;; CHECK:      (func $if-else-mixed (type $void)
 ;; CHECK-NEXT:  (if
 ;; CHECK-NEXT:   (if (result i32)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (if
 ;; CHECK-NEXT:    (if (result i32)
 ;; CHECK-NEXT:     (i32.const 3)
 ;; CHECK-NEXT:     (i32.const 4)
 ;; CHECK-NEXT:     (i32.const 5)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (if
 ;; CHECK-NEXT:     (i32.const 6)
 ;; CHECK-NEXT:     (drop
 ;; CHECK-NEXT:      (i32.const 7)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-mixed
  i32.const 0
  if (result i32)
   i32.const 1
  else
   i32.const 2
  end
  if
   (if
    (if (result i32)
     (i32.const 3)
     (then
      (i32.const 4)
     )
     (else
      (i32.const 5)
     )
    )
    (then
     i32.const 6
     if
      i32.const 7
      drop
     end
    )
   )
  end
 )

 ;; CHECK:      (func $if-else-brs (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (if
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (br $label)
 ;; CHECK-NEXT:    (br $label)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-brs
  i32.const 0
  if
   br 0
  else
   br 0
  end
 )

 ;; CHECK:      (func $if-else-brs-i32 (type $1) (result i32)
 ;; CHECK-NEXT:  (block $label (result i32)
 ;; CHECK-NEXT:   (if (result i32)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (br $label
 ;; CHECK-NEXT:     (i32.const 1)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (br $label
 ;; CHECK-NEXT:     (i32.const 2)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $if-else-brs-i32 (result i32)
  i32.const 0
  if (result i32)
   i32.const 1
   br 0
  else
   i32.const 2
   br 0
  end
 )

 ;; CHECK:      (func $loop (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop
  loop
   nop
  end
 )

 ;; CHECK:      (func $loop-empty (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-empty
  loop
  end
 )

 ;; CHECK:      (func $loop-many (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-many
  loop
   nop
   nop
  end
 )

 ;; CHECK:      (func $loop-nested (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-nested
  loop
   i32.const 0
   drop
  end
 )

 ;; CHECK:      (func $loop-folded-body (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-body
  loop
   (drop
    (i32.const 0)
   )
  end
 )

 ;; CHECK:      (func $loop-labeled (type $void)
 ;; CHECK-NEXT:  (loop $l
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-labeled
  loop $l
   nop
  end $l
 )

 ;; CHECK:      (func $loop-result (type $1) (result i32)
 ;; CHECK-NEXT:  (loop (result i32)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-result (result i32)
  loop (result i32)
   i32.const 0
  end
 )

 ;; CHECK:      (func $loop-labeled-result (type $1) (result i32)
 ;; CHECK-NEXT:  (loop $l (result i32)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-labeled-result (result i32)
  loop $l (result i32)
   i32.const 0
  end $l
 )

 ;; CHECK:      (func $loop-folded (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded
  (loop
   (nop)
  )
 )

 ;; CHECK:      (func $loop-folded-empty (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-empty
  (loop)
 )

 ;; CHECK:      (func $loop-folded-many (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-many
  (loop
   nop
   nop
  )
 )

 ;; CHECK:      (func $loop-folded-nested (type $void)
 ;; CHECK-NEXT:  (loop
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (f32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-nested
  (loop
   (drop
    (f32.const 0)
   )
  )
 )

 ;; CHECK:      (func $loop-folded-labeled (type $void)
 ;; CHECK-NEXT:  (loop $l
 ;; CHECK-NEXT:   (nop)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-labeled
  (loop $l
   nop
  )
 )

 ;; CHECK:      (func $loop-folded-result (type $1) (result i32)
 ;; CHECK-NEXT:  (loop (result i32)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-result (result i32)
  (loop (result i32)
   i32.const 0
  )
 )

 ;; CHECK:      (func $loop-folded-labeled-result (type $1) (result i32)
 ;; CHECK-NEXT:  (loop $l (result i32)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $loop-folded-labeled-result (result i32)
  (loop $l (result i32)
   i32.const 0
  )
 )

 ;; CHECK:      (func $try (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try
  try
   nop
  end
 )

 ;; CHECK:      (func $try-catch (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch $empty
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-catch
  try
  catch $empty
  end
 )

 ;; CHECK:      (func $try-catch-params (type $5) (result i32 i64)
 ;; CHECK-NEXT:  (try (type $5) (result i32 i64)
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (tuple.make 2
 ;; CHECK-NEXT:     (i32.const 0)
 ;; CHECK-NEXT:     (i64.const 1)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch $tag-pair
 ;; CHECK-NEXT:    (pop i32 i64)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-catch-params (result i32 i64)
  try (result i32 i64)
   i32.const 0
   i64.const 1
  catch $tag-pair
  end
 )


 ;; CHECK:      (func $try-catch_all (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch_all
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-catch_all
  try
  catch_all
  end
 )

 ;; CHECK:      (func $try-catch-catch_all (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch $empty
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch $timport$0
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch_all
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-catch-catch_all
  try
  catch $empty
  catch 1
  catch_all
  end
 )

 ;; CHECK:      (func $try-delegate (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (delegate 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate
  try
  delegate 0
 )

 ;; CHECK:      (func $try-delegate-nested-func-direct (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (delegate 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-func-direct
  block $l
   try
   delegate 1
  end
 )

 ;; CHECK:      (func $try-delegate-nested-func-indirect-index (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (delegate 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-func-indirect-index
  block $l
   try
   delegate 0
  end
 )

 ;; CHECK:      (func $try-delegate-nested-func-indirect-name (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (delegate 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-func-indirect-name
  block $l
   try
   delegate $l
  end
 )

 ;; CHECK:      (func $try-delegate-nested-try-direct-index (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try $__delegate__label
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (nop)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (delegate $__delegate__label)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-try-direct-index
  try
   block
    try
    delegate 1
   end
  end
 )

 ;; CHECK:      (func $try-delegate-nested-try-direct-name (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (nop)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (delegate $__delegate__l)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-try-direct-name
  try $l
   block
    try
    delegate $l
   end
  end
 )

 ;; CHECK:      (func $try-delegate-nested-try-indirect-index (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try $__delegate__label
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (nop)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (delegate $__delegate__label)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-try-indirect-index
  try
   block
    try
    delegate 0
   end
  end
 )

 ;; CHECK:      (func $try-delegate-nested-try-indirect-name (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try $__delegate__label
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (block $l
 ;; CHECK-NEXT:      (try
 ;; CHECK-NEXT:       (do
 ;; CHECK-NEXT:        (nop)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:       (delegate $__delegate__label)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-try-indirect-name
  try
   block $l
    try
    delegate $l
   end
  end
 )

 ;; CHECK:      (func $try-delegate-nested-try-shadowing (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (block $l_0
 ;; CHECK-NEXT:      (block $l_1
 ;; CHECK-NEXT:       (try
 ;; CHECK-NEXT:        (do
 ;; CHECK-NEXT:         (nop)
 ;; CHECK-NEXT:        )
 ;; CHECK-NEXT:        (delegate $__delegate__l)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-try-shadowing
  try $l
   block $l
    try $l
    delegate $l
   end
  end $l
 )

 ;; CHECK:      (func $try-delegate-nested-catch-shadowing (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (block $l_0
 ;; CHECK-NEXT:      (try
 ;; CHECK-NEXT:       (do
 ;; CHECK-NEXT:        (nop)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:       (catch $empty
 ;; CHECK-NEXT:        (block $l_1
 ;; CHECK-NEXT:         (try
 ;; CHECK-NEXT:          (do
 ;; CHECK-NEXT:           (nop)
 ;; CHECK-NEXT:          )
 ;; CHECK-NEXT:          (delegate $__delegate__l)
 ;; CHECK-NEXT:         )
 ;; CHECK-NEXT:        )
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-catch-shadowing
  try $l
   try $l
   catch $empty
    try $l
    ;; goes to the outermost try, not the middle one
    delegate $l
   end
  end
 )

 ;; CHECK:      (func $try-delegate-nested-catch_all-shadowing (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (block $l_0
 ;; CHECK-NEXT:      (try
 ;; CHECK-NEXT:       (do
 ;; CHECK-NEXT:        (nop)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:       (catch_all
 ;; CHECK-NEXT:        (block $l_1
 ;; CHECK-NEXT:         (try
 ;; CHECK-NEXT:          (do
 ;; CHECK-NEXT:           (nop)
 ;; CHECK-NEXT:          )
 ;; CHECK-NEXT:          (delegate $__delegate__l)
 ;; CHECK-NEXT:         )
 ;; CHECK-NEXT:        )
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-nested-catch_all-shadowing
  try $l
   try $l
   catch_all
    try $l
    ;; goes to the outermost try, not the middle one
    delegate $l
   end
  end
 )

 ;; CHECK:      (func $try-br-index (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (br $label)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (br $label)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch_all
 ;; CHECK-NEXT:     (br $label)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-br-index
  try
   br 0
  catch $empty
   br 0
  catch_all
   br 0
  end
 )

 ;; CHECK:      (func $try-br-name (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (br $l)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (br $l)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch_all
 ;; CHECK-NEXT:     (br $l)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-br-name
  try $l
   br $l
  catch $l $empty
   br $l
  catch_all $l
   br $l
  end $l
 )

 ;; CHECK:      (func $try-folded (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch $empty
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch $timport$0
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (catch_all
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-folded
  (try
   (do
    nop
    (nop)
   )
   (catch $empty
    (nop)
    nop
   )
   (catch 1
    nop
    (nop)
   )
   (catch_all
    (nop)
    nop
   )
  )
 )

 ;; CHECK:      (func $try-delegate-folded (type $void)
 ;; CHECK-NEXT:  (try
 ;; CHECK-NEXT:   (do
 ;; CHECK-NEXT:    (nop)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (delegate 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $try-delegate-folded
  (try
   (do)
   (delegate 0)
  )
 )

 ;; CHECK:      (func $rethrow (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try $__delegate__label
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (rethrow $__delegate__label)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $rethrow
  try
  catch $empty
   rethrow 0
  end
 )

 ;; CHECK:      (func $rethrow-named (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (rethrow $__delegate__l)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $rethrow-named
  try $l
  catch $empty
   rethrow $l
  end
 )

 ;; CHECK:      (func $rethrow-nested (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try $__delegate__label
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (nop)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (catch $empty
 ;; CHECK-NEXT:       (rethrow $__delegate__label)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $rethrow-nested
  try
  catch $empty
   block
    try
    catch $empty
     rethrow 2
    end
   end
  end
 )

 ;; CHECK:      (func $rethrow-nested-named (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (nop)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:      (catch $empty
 ;; CHECK-NEXT:       (rethrow $__delegate__l)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $rethrow-nested-named
  try $l
  catch $empty
   block
    try
    catch $empty
     rethrow $l
    end
   end
  end
 )

 ;; CHECK:      (func $rethrow-try-nested (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (try $__delegate__label
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (rethrow $__delegate__label)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $rethrow-try-nested
  try
  catch $empty
   block
    try
     ;; Same as before, but now the rethrow is in the inner try instead of the
     ;; inner catch.
     rethrow 2
    end
   end
  end
 )

 ;; CHECK:      (func $rethrow-try-nested-named (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (try $__delegate__l
 ;; CHECK-NEXT:    (do
 ;; CHECK-NEXT:     (nop)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (catch $empty
 ;; CHECK-NEXT:     (try
 ;; CHECK-NEXT:      (do
 ;; CHECK-NEXT:       (rethrow $__delegate__l)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $rethrow-try-nested-named
  try $l
  catch $empty
   block
    try
     rethrow $l
    end
   end
  end
 )

 ;; CHECK:      (func $label-siblings (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (br $l)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (loop $l_0
 ;; CHECK-NEXT:   (br $l_0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (block $l_1
 ;; CHECK-NEXT:   (if
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (br $l_1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $label-siblings
  block $l
   br $l
  end
  loop $l
   br $l
  end
  i32.const 0
  if $l
   br $l
  end
 )

 ;; CHECK:      (func $label-shadowed (type $void)
 ;; CHECK-NEXT:  (block $l
 ;; CHECK-NEXT:   (br $l)
 ;; CHECK-NEXT:   (loop $l_0
 ;; CHECK-NEXT:    (br $l_0)
 ;; CHECK-NEXT:    (block $l_1
 ;; CHECK-NEXT:     (if
 ;; CHECK-NEXT:      (i32.const 0)
 ;; CHECK-NEXT:      (br $l_1)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (br $l_0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:   (br $l)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $label-shadowed
  block $l
   br $l
   loop $l
    br $l
    i32.const 0
    if $l
     br $l
    end
    br $l
   end
   br $l
  end
 )

 ;; CHECK:      (func $label-index (type $void)
 ;; CHECK-NEXT:  (block $label_1
 ;; CHECK-NEXT:   (block $label
 ;; CHECK-NEXT:    (block $label_0
 ;; CHECK-NEXT:     (block $l
 ;; CHECK-NEXT:      (br $label)
 ;; CHECK-NEXT:      (br $label_0)
 ;; CHECK-NEXT:      (br $l)
 ;; CHECK-NEXT:      (br $label_1)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $label-index
  block
   block
    block
     block $l
      br 2
      br 1
      br 0
      br 3
     end
    end
   end
  end
 )

 ;; CHECK:      (func $label-func (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (block
 ;; CHECK-NEXT:    (br $label)
 ;; CHECK-NEXT:    (block $a
 ;; CHECK-NEXT:     (br $label)
 ;; CHECK-NEXT:     (block $b
 ;; CHECK-NEXT:      (br $label)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $label-func
  br 0
  block $a
   br 1
   block $b
    br 2
   end
  end
 )

 ;; CHECK:      (func $br-value (type $1) (result i32)
 ;; CHECK-NEXT:  (block $label (result i32)
 ;; CHECK-NEXT:   (br $label
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-value (result i32)
  i32.const 0
  br 0
 )

 ;; CHECK:      (func $br-value-drop (type $1) (result i32)
 ;; CHECK-NEXT:  (block $label (result i32)
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (f32.const 0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (br $label
 ;; CHECK-NEXT:     (i32.const 1)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-value-drop (result i32)
  f32.const 0
  i32.const 1
  br 0
 )

 ;; CHECK:      (func $br-multivalue (type $5) (result i32 i64)
 ;; CHECK-NEXT:  (block $label (type $5) (result i32 i64)
 ;; CHECK-NEXT:   (br $label
 ;; CHECK-NEXT:    (tuple.make 2
 ;; CHECK-NEXT:     (i32.const 0)
 ;; CHECK-NEXT:     (i64.const 1)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-multivalue (result i32 i64)
  i32.const 0
  i64.const 1
  br 0
 )

 ;; CHECK:      (func $br-multivalue-drop (type $5) (result i32 i64)
 ;; CHECK-NEXT:  (block $label (type $5) (result i32 i64)
 ;; CHECK-NEXT:   (block (type $5) (result i32 i64)
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (f32.const 0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (br $label
 ;; CHECK-NEXT:     (tuple.make 2
 ;; CHECK-NEXT:      (i32.const 1)
 ;; CHECK-NEXT:      (i64.const 2)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-multivalue-drop (result i32 i64)
  f32.const 0
  i32.const 1
  i64.const 2
  br 0
 )

 ;; CHECK:      (func $br-table (type $void)
 ;; CHECK-NEXT:  (block $a
 ;; CHECK-NEXT:   (block $b
 ;; CHECK-NEXT:    (block $c
 ;; CHECK-NEXT:     (block $d
 ;; CHECK-NEXT:      (br_table $a $b $d $c
 ;; CHECK-NEXT:       (i32.const 0)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-table
  block $a
   block $b
    block $c
     block $d
      i32.const 0
      br_table $a $b $d $c
     end
    end
   end
  end
 )

 ;; CHECK:      (func $br-table-index (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (block $l
 ;; CHECK-NEXT:    (block $label_1
 ;; CHECK-NEXT:     (block $label_0
 ;; CHECK-NEXT:      (br_table $label $l $label_0 $label_1
 ;; CHECK-NEXT:       (i32.const 0)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-table-index
  block
   block $l
    block
     block
      i32.const 0
      br_table 3 2 0 1
     end
    end
   end
  end
 )

 ;; CHECK:      (func $br-table-return (type $void)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (br_table $label $label $label $label $label $label $label $label
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-table-return
  i32.const 0
  br_table 0 0 0 0 0 0 0 0
 )

 ;; CHECK:      (func $br-table-value (type $1) (result i32)
 ;; CHECK-NEXT:  (block $a (result i32)
 ;; CHECK-NEXT:   (block $b (result i32)
 ;; CHECK-NEXT:    (br_table $a $b
 ;; CHECK-NEXT:     (i32.const 42)
 ;; CHECK-NEXT:     (i32.const 0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-table-value (result i32)
  block $a (result i32)
   block $b (result i32)
    i32.const 42
    i32.const 0
    br_table $a $b
   end
  end
 )

 ;; CHECK:      (func $br-table-multivalue (type $5) (result i32 i64)
 ;; CHECK-NEXT:  (block $a (type $5) (result i32 i64)
 ;; CHECK-NEXT:   (block $b (type $5) (result i32 i64)
 ;; CHECK-NEXT:    (br_table $a $b
 ;; CHECK-NEXT:     (tuple.make 2
 ;; CHECK-NEXT:      (i32.const 42)
 ;; CHECK-NEXT:      (i64.const 42)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:     (i32.const 0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-table-multivalue (result i32 i64)
  block $a (result i32 i64)
   block $b (result i32 i64)
    i32.const 42
    i64.const 42
    i32.const 0
    br_table $a $b
   end
  end
 )


 ;; CHECK:      (func $binary (type $27) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.add
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (f64.mul
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:    (local.get $3)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $binary (param i32 i32 f64 f64)
  local.get 0
  local.get 1
  i32.add
  drop
  local.get 2
  local.get 3
  f64.mul
  drop
 )

 ;; CHECK:      (func $unary (type $28) (param $0 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i64.eqz
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $unary (param i64)
  local.get 0
  i64.eqz
  drop
 )

 ;; CHECK:      (func $select (type $17) (param $0 i32) (param $1 i32) (param $2 i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (select
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (select
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (select
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (select
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $select (param i32 i32 i32)
  local.get 0
  local.get 1
  local.get 2
  select
  drop
  local.get 0
  local.get 1
  local.get 2
  select (result)
  drop
  local.get 0
  local.get 1
  local.get 2
  select (result i32)
  drop
  local.get 0
  local.get 1
  local.get 2
  select (result) (result i32) (result)
  drop
 )

 ;; CHECK:      (func $memory-size (type $void)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.size $mimport$0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.size $m-imported)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.size $mem-i64)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $memory-size
  memory.size
  drop
  memory.size 1
  drop
  memory.size $mem-i64
  drop
 )

 ;; CHECK:      (func $memory-grow (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.grow $mimport$0
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.grow $m-imported
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.grow $mem-i64
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $memory-grow (param i32 i64)
  local.get 0
  memory.grow
  drop
  local.get 0
  memory.grow 1
  drop
  local.get 1
  memory.grow $mem-i64
  drop
 )

 ;; CHECK:      (func $globals (type $void)
 ;; CHECK-NEXT:  (global.set $g-imported
 ;; CHECK-NEXT:   (global.get $i32)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $globals
  global.get $i32
  global.set 4
 )

 ;; CHECK:      (func $load (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.load $mimport$0 offset=42
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i64.load8_s $m-imported
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.atomic.load16_u $mem-i64 offset=42
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $load (param i32 i64)
  local.get 0
  i32.load offset=42
  drop
  local.get 0
  i64.load8_s 1 align=1
  drop
  local.get 1
  i32.atomic.load16_u $mem-i64 offset=42 align=2
  drop
 )

 ;; CHECK:      (func $store (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (i32.store $mimport$0 offset=42 align=1
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (i64.atomic.store8 $m-imported
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (i64.const 1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (f32.store $mem-i64
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (f32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $store (param i32 i64)
  local.get 0
  i32.const 0
  i32.store offset=42 align=1
  local.get 0
  i64.const 1
  i64.atomic.store8 1
  local.get 1
  f32.const 2
  f32.store $mem-i64
 )

 ;; CHECK:      (func $atomic-rmw (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.atomic.rmw16.add_u $mimport$0
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i64.atomic.rmw.xor $mem-i64 offset=8
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (i64.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $atomic-rmw (param i32 i64)
  local.get 0
  i32.const 1
  i32.atomic.rmw16.add_u
  drop
  local.get 1
  i64.const 2
  i64.atomic.rmw.xor $mem-i64 offset=8 align=8
  drop
 )

 ;; CHECK:      (func $atomic-cmpxchg (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i32.atomic.rmw8.cmpxchg_u $mem
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i64.atomic.rmw32.cmpxchg_u $mem-i64 offset=16
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (i64.const 3)
 ;; CHECK-NEXT:    (i64.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $atomic-cmpxchg (param i32 i64)
  local.get 0
  i32.const 1
  i32.const 2
  i32.atomic.rmw8.cmpxchg_u 2 align=1
  drop
  local.get 1
  i64.const 3
  i64.const 4
  i64.atomic.rmw32.cmpxchg_u 5 offset=16
  drop
 )

 ;; CHECK:      (func $atomic-wait (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.atomic.wait32 $mimport$0
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i64.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.atomic.wait64 $mem-i64 offset=8
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (i64.const 3)
 ;; CHECK-NEXT:    (i64.const 4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $atomic-wait (param i32 i64)
  local.get 0
  i32.const 1
  i64.const 2
  memory.atomic.wait32
  drop
  local.get 1
  i64.const 3
  i64.const 4
  memory.atomic.wait64 $mem-i64 offset=8 align=8
  drop
 )

 ;; CHECK:      (func $atomic-notify (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.atomic.notify $mimport$0 offset=8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (memory.atomic.notify $mem-i64
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $atomic-notify (param i32 i64)
  local.get 0
  i32.const 0
  memory.atomic.notify offset=8 align=4
  drop
  local.get 1
  i32.const 1
  memory.atomic.notify $mem-i64
  drop
 )

 ;; CHECK:      (func $atomic-fence (type $void)
 ;; CHECK-NEXT:  (atomic.fence)
 ;; CHECK-NEXT: )
 (func $atomic-fence
  atomic.fence
 )

 ;; CHECK:      (func $simd-extract (type $29) (param $0 v128) (result i32)
 ;; CHECK-NEXT:  (i32x4.extract_lane 3
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-extract (param v128) (result i32)
  local.get 0
  i32x4.extract_lane 3
 )

 ;; CHECK:      (func $simd-replace (type $18) (param $0 v128) (param $1 i32) (result v128)
 ;; CHECK-NEXT:  (i32x4.replace_lane 2
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-replace (param v128 i32) (result v128)
  local.get 0
  local.get 1
  i32x4.replace_lane 2
 )

 ;; CHECK:      (func $simd-shuffle (type $30) (param $0 v128) (param $1 v128) (result v128)
 ;; CHECK-NEXT:  (i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-shuffle (param v128 v128) (result v128)
  local.get 0
  local.get 1
  i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
 )

 ;; CHECK:      (func $simd-ternary (type $31) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
 ;; CHECK-NEXT:  (v128.bitselect
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-ternary (param v128 v128 v128) (result v128)
  local.get 0
  local.get 1
  local.get 2
  v128.bitselect
 )

 ;; CHECK:      (func $simd-shift (type $18) (param $0 v128) (param $1 i32) (result v128)
 ;; CHECK-NEXT:  (i8x16.shl
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-shift (param v128 i32) (result v128)
  local.get 0
  local.get 1
  i8x16.shl
 )

 ;; CHECK:      (func $simd-load (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (v128.load8x8_s $mimport$0 offset=8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (v128.load16_splat $mem-i64 offset=2 align=1
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-load (param i32 i64)
  local.get 0
  v128.load8x8_s offset=8 align=8
  drop
  local.get 1
  v128.load16_splat $mem-i64 offset=2 align=1
  drop
 )

 ;; CHECK:      (func $simd-load-store-lane (type $9) (param $0 i32) (param $1 i64) (param $2 v128)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (v128.load16_lane $mimport$0 7
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (v128.store64_lane $mem-i64 align=4 0
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $simd-load-store-lane (param i32 i64 v128)
  local.get 0
  local.get 2
  v128.load16_lane 7
  drop
  local.get 1
  local.get 2
  v128.store64_lane 5 align=4 0
 )

 ;; CHECK:      (func $memory-init (type $17) (param $0 i32) (param $1 i32) (param $2 i32)
 ;; CHECK-NEXT:  (memory.init $mem-i32 $passive
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (memory.init $mem-i64 $0
 ;; CHECK-NEXT:   (i64.const 0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (memory.init $mimport$0 $implicit-data
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $memory-init (param i32 i32 i32)
  local.get 0
  local.get 1
  local.get 2
  memory.init $mem-i32 $passive
  i64.const 0
  local.get 1
  local.get 2
  memory.init 5 1
  local.get 0
  local.get 1
  local.get 2
  memory.init 0
 )

 ;; CHECK:      (func $data-drop (type $void)
 ;; CHECK-NEXT:  (data.drop $implicit-data)
 ;; CHECK-NEXT:  (data.drop $passive)
 ;; CHECK-NEXT: )
 (func $data-drop
  data.drop 0
  data.drop $passive
 )

 ;; CHECK:      (func $memory-copy (type $32) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
 ;; CHECK-NEXT:  (memory.copy $mimport$0 $mimport$0
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (memory.copy $mem $mem-i32
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (i32.const 3)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (memory.copy $mem-i64 $mem-i64
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $3)
 ;; CHECK-NEXT:   (i64.const 4)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $memory-copy (param i32 i32 i64 i64)
  local.get 0
  local.get 1
  i32.const 2
  memory.copy
  local.get 0
  local.get 1
  i32.const 3
  memory.copy 2 $mem-i32
  local.get 2
  local.get 3
  i64.const 4
  memory.copy $mem-i64 5
 )

 ;; CHECK:      (func $memory-fill (type $4) (param $0 i32) (param $1 i64)
 ;; CHECK-NEXT:  (memory.fill $mimport$0
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (memory.fill $mimport$0
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (i32.const 3)
 ;; CHECK-NEXT:   (i32.const 4)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (memory.fill $mem-i64
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (i32.const 5)
 ;; CHECK-NEXT:   (i64.const 6)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $memory-fill (param i32 i64)
  local.get 0
  i32.const 1
  i32.const 2
  memory.fill
  local.get 0
  i32.const 3
  i32.const 4
  memory.fill 0
  local.get 1
  i32.const 5
  i64.const 6
  memory.fill $mem-i64
 )

 ;; CHECK:      (func $return-none (type $void)
 ;; CHECK-NEXT:  (return)
 ;; CHECK-NEXT: )
 (func $return-none
  return
 )

 ;; CHECK:      (func $return-one (type $33) (param $0 i32) (result i32)
 ;; CHECK-NEXT:  (return
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return-one (param i32) (result i32)
  local.get 0
  return
 )

 ;; CHECK:      (func $return-two (type $34) (param $0 i32) (param $1 i64) (result i32 i64)
 ;; CHECK-NEXT:  (return
 ;; CHECK-NEXT:   (tuple.make 2
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return-two (param i32 i64) (result i32 i64)
  local.get 0
  local.get 1
  return
 )

 ;; CHECK:      (func $return-two-first-unreachable (type $35) (param $0 i64) (result i32 i64)
 ;; CHECK-NEXT:  (return
 ;; CHECK-NEXT:   (tuple.make 2
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return-two-first-unreachable (param i64) (result i32 i64)
  unreachable
  local.get 0
  return
 )

 ;; CHECK:      (func $return-two-second-unreachable (type $36) (param $0 i32) (result i32 i64)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return
 ;; CHECK-NEXT:   (tuple.make 2
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return-two-second-unreachable (param i32) (result i32 i64)
  local.get 0
  unreachable
  return
 )

 ;; CHECK:      (func $ref-is-null (type $37) (param $0 anyref) (result i32)
 ;; CHECK-NEXT:  (ref.is_null
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $ref-is-null (param anyref) (result i32)
  local.get 0
  ref.is_null
 )

 ;; CHECK:      (func $ref-func (type $void)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.func $ref-func)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.func $ref-is-null)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $ref-func
  ref.func $ref-func
  drop
  ref.func 135
  drop
 )

 ;; CHECK:      (func $throw (type $void)
 ;; CHECK-NEXT:  (throw $timport$1)
 ;; CHECK-NEXT:  (throw $tag-i32
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (throw $tag-pair
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i64.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $throw
  throw 2
  i32.const 0
  throw $tag-i32
  i32.const 1
  i64.const 2
  throw $tag-pair
 )

 ;; CHECK:      (func $ref-eq (type $38) (param $0 eqref) (param $1 eqref) (result i32)
 ;; CHECK-NEXT:  (ref.eq
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $ref-eq (param eqref eqref) (result i32)
  local.get 0
  local.get 1
  ref.eq
 )

 ;; CHECK:      (func $table-get (type $void)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.get $timport$0
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.get $timport$1
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.get $table-any
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $table-get
  i32.const 0
  table.get
  drop
  i32.const 1
  table.get 1
  drop
  i32.const 2
  table.get $table-any
  drop
 )

 ;; CHECK:      (func $table-set (type $void)
 ;; CHECK-NEXT:  (table.set $timport$0
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (ref.null nofunc)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (table.set $funcs
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (ref.func $table-set)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (table.set $table-any
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:   (ref.null none)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $table-set
  i32.const 0
  ref.null func
  table.set
  i32.const 1
  ref.func $table-set
  table.set 2
  i32.const 2
  ref.null any
  table.set $table-any
 )

 ;; CHECK:      (func $table-size (type $void)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.size $timport$0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.size $timport$1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.size $table-any)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $table-size
  table.size
  drop
  table.size 1
  drop
  table.size $table-any
  drop
 )

 ;; CHECK:      (func $table-grow (type $void)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.grow $timport$0
 ;; CHECK-NEXT:    (ref.null nofunc)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.grow $funcs
 ;; CHECK-NEXT:    (ref.func $table-grow)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (table.grow $table-any
 ;; CHECK-NEXT:    (ref.null none)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $table-grow
  ref.null func
  i32.const 0
  table.grow
  drop
  ref.func $table-grow
  i32.const 1
  table.grow 2
  drop
  ref.null any
  i32.const 2
  table.grow $table-any
  drop
 )

 ;; CHECK:      (func $table-fill (type $void)
 ;; CHECK-NEXT:  (table.fill $timport$0
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (ref.null nofunc)
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (table.fill $funcs
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:   (ref.func $table-fill)
 ;; CHECK-NEXT:   (i32.const 3)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (table.fill $table-any
 ;; CHECK-NEXT:   (i32.const 4)
 ;; CHECK-NEXT:   (ref.null none)
 ;; CHECK-NEXT:   (i32.const 5)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $table-fill
  i32.const 0
  ref.null func
  i32.const 1
  table.fill
  i32.const 2
  ref.func $table-fill
  i32.const 3
  table.fill 2
  i32.const 4
  ref.null any
  i32.const 5
  table.fill $table-any
 )

 ;; CHECK:      (func $table-copy (type $void)
 ;; CHECK-NEXT:  (table.copy $timport$0 $timport$0
 ;; CHECK-NEXT:   (i32.const 0)
 ;; CHECK-NEXT:   (i32.const 1)
 ;; CHECK-NEXT:   (i32.const 2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (table.copy $funcs $funcs
 ;; CHECK-NEXT:   (i32.const 3)
 ;; CHECK-NEXT:   (i32.const 4)
 ;; CHECK-NEXT:   (i32.const 5)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $table-copy
  i32.const 0
  i32.const 1
  i32.const 2
  table.copy
  i32.const 3
  i32.const 4
  i32.const 5
  table.copy 2 $funcs
 )

 ;; CHECK:      (func $i31-new (type $39) (param $0 i32) (result i31ref)
 ;; CHECK-NEXT:  (ref.i31
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $i31-new (param i32) (result i31ref)
  local.get 0
  ref.i31
 )

 ;; CHECK:      (func $i31-get (type $40) (param $0 i31ref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i31.get_s
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (i31.get_u
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $i31-get (param i31ref)
  local.get 0
  i31.get_s
  drop
  local.get 0
  i31.get_u
  drop
 )

 ;; CHECK:      (func $call-ref (type $void)
 ;; CHECK-NEXT:  (local $0 (ref null $void))
 ;; CHECK-NEXT:  (local $1 (ref null $ret2))
 ;; CHECK-NEXT:  (local $2 (ref null $many))
 ;; CHECK-NEXT:  (local $scratch (i32 i32))
 ;; CHECK-NEXT:  (local $scratch_4 i32)
 ;; CHECK-NEXT:  (local $scratch_5 (anyref (ref func)))
 ;; CHECK-NEXT:  (local $scratch_6 anyref)
 ;; CHECK-NEXT:  (call_ref $void
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (block (result i32)
 ;; CHECK-NEXT:    (local.set $scratch_4
 ;; CHECK-NEXT:     (tuple.extract 2 0
 ;; CHECK-NEXT:      (local.tee $scratch
 ;; CHECK-NEXT:       (call_ref $ret2
 ;; CHECK-NEXT:        (local.get $1)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (tuple.extract 2 1
 ;; CHECK-NEXT:      (local.get $scratch)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (local.get $scratch_4)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (block (result anyref)
 ;; CHECK-NEXT:    (local.set $scratch_6
 ;; CHECK-NEXT:     (tuple.extract 2 0
 ;; CHECK-NEXT:      (local.tee $scratch_5
 ;; CHECK-NEXT:       (call_ref $many
 ;; CHECK-NEXT:        (i32.const 0)
 ;; CHECK-NEXT:        (i64.const 1)
 ;; CHECK-NEXT:        (f32.const 2)
 ;; CHECK-NEXT:        (f64.const 3)
 ;; CHECK-NEXT:        (local.get $2)
 ;; CHECK-NEXT:       )
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (tuple.extract 2 1
 ;; CHECK-NEXT:      (local.get $scratch_5)
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (local.get $scratch_6)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $call-ref
  (local (ref null $void) (ref null $ret2) (ref null $many))
  local.get 0
  call_ref $void
  local.get 1
  call_ref $ret2
  drop
  drop
  i32.const 0
  i64.const 1
  f32.const 2
  f64.const 3
  local.get 2
  call_ref $many
  drop
  drop
 )

 ;; CHECK:      (func $ref-test (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.test i31ref
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.test (ref $s0)
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $ref-test (param anyref)
  local.get 0
  ref.test i31ref
  drop
  local.get 0
  ref.test (ref $s0)
  drop
 )

 ;; CHECK:      (func $ref-cast (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.cast i31ref
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.cast (ref $s0)
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $ref-cast (param anyref)
  local.get 0
  ref.cast i31ref
  drop
  local.get 0
  ref.cast (ref $s0)
  drop
 )

 ;; CHECK:      (func $br-on-null (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (block $label
 ;; CHECK-NEXT:   (drop
 ;; CHECK-NEXT:    (br_on_null $label
 ;; CHECK-NEXT:     (local.get $0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-on-null (param anyref)
  local.get 0
  br_on_null 0
  drop
 )

 ;; CHECK:      (func $br-on-non-null (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (block $label (result (ref any))
 ;; CHECK-NEXT:    (br_on_non_null $label
 ;; CHECK-NEXT:     (local.get $0)
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-on-non-null (param anyref)
  block (result (ref any))
   local.get 0
   br_on_non_null 0
   unreachable
  end
  drop
 )

 ;; CHECK:      (func $br-on-cast (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (block $label (result i31ref)
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (block (result (ref any))
 ;; CHECK-NEXT:      (br_on_cast $label anyref i31ref
 ;; CHECK-NEXT:       (local.get $0)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-on-cast (param anyref)
  block (result i31ref)
   block (result (ref any))
    local.get 0
    br_on_cast 1 anyref i31ref
   end
   unreachable
  end
  drop
 )

 ;; CHECK:      (func $br-on-cast-fail (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (block $label (result (ref any))
 ;; CHECK-NEXT:    (drop
 ;; CHECK-NEXT:     (block (result i31ref)
 ;; CHECK-NEXT:      (br_on_cast_fail $label anyref i31ref
 ;; CHECK-NEXT:       (local.get $0)
 ;; CHECK-NEXT:      )
 ;; CHECK-NEXT:     )
 ;; CHECK-NEXT:    )
 ;; CHECK-NEXT:    (unreachable)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $br-on-cast-fail (param anyref)
  block (result (ref any))
   block (result i31ref)
    local.get 0
    br_on_cast_fail 1 anyref i31ref
   end
   unreachable
  end
  drop
 )

 ;; CHECK:      (func $struct-new (type $41) (param $0 i32) (param $1 i64) (result (ref $pair))
 ;; CHECK-NEXT:  (struct.new $pair
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $struct-new (param i32 i64) (result (ref $pair))
  local.get 0
  local.get 1
  struct.new $pair
 )

 ;; CHECK:      (func $struct-new-default (type $42) (result (ref $pair))
 ;; CHECK-NEXT:  (struct.new_default $pair)
 ;; CHECK-NEXT: )
 (func $struct-new-default (result (ref $pair))
  struct.new_default 14
 )

 ;; CHECK:      (func $struct-get-0 (type $43) (param $0 (ref $pair)) (result i32)
 ;; CHECK-NEXT:  (struct.get $pair 0
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $struct-get-0 (param (ref $pair)) (result i32)
  local.get 0
  struct.get 14 0
 )

 ;; CHECK:      (func $struct-get-1 (type $44) (param $0 (ref $pair)) (result i64)
 ;; CHECK-NEXT:  (struct.get $pair 1
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $struct-get-1 (param (ref $pair)) (result i64)
  local.get 0
  struct.get $pair 1
 )

 ;; CHECK:      (func $struct-set-0 (type $45) (param $0 (ref $pair)) (param $1 i32)
 ;; CHECK-NEXT:  (struct.set $pair 0
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $struct-set-0 (param (ref $pair) i32)
  local.get 0
  local.get 1
  struct.set $pair 0
 )

 ;; CHECK:      (func $struct-set-1 (type $46) (param $0 (ref $pair)) (param $1 i64)
 ;; CHECK-NEXT:  (struct.set $pair 1
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $struct-set-1 (param (ref $pair) i64)
  local.get 0
  local.get 1
  struct.set 14 1
 )

 ;; CHECK:      (func $array-new (type $47) (param $0 i64) (param $1 i32) (result (ref $a1))
 ;; CHECK-NEXT:  (array.new $a1
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-new (param i64 i32) (result (ref 11))
  local.get 0
  local.get 1
  array.new $a1
 )

 ;; CHECK:      (func $array-new-default (type $48) (param $0 i32) (result (ref $a1))
 ;; CHECK-NEXT:  (array.new_default $a1
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-new-default (param i32) (result (ref $a1))
  local.get 0
  array.new_default 11
 )

 ;; CHECK:      (func $array-new-data (type $49) (param $0 i32) (param $1 i32) (result (ref $a1))
 ;; CHECK-NEXT:  (array.new_data $a1 $implicit-data
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-new-data (param i32 i32) (result (ref $a1))
  local.get 0
  local.get 1
  array.new_data $a1 0
 )

 ;; CHECK:      (func $array-new-fixed (type $void)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (array.new_fixed $a0 0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (array.new_fixed $a0 3
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-new-fixed
  array.new_fixed $a0 0
  drop
  i32.const 0
  i32.const 1
  i32.const 2
  array.new_fixed $a0 3
  drop
 )

 ;; CHECK:      (func $array-get (type $50) (param $0 (ref $a1)) (param $1 i32) (result i64)
 ;; CHECK-NEXT:  (array.get $a1
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-get (param (ref 11) i32) (result i64)
  local.get 0
  local.get 1
  array.get $a1
 )

 ;; CHECK:      (func $array-get-s (type $51) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
 ;; CHECK-NEXT:  (array.get_s $packed-i8
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-get-s (param (ref $packed-i8) i32) (result i32)
  local.get 0
  local.get 1
  array.get_s 15
 )

 ;; CHECK:      (func $array-get-u (type $52) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
 ;; CHECK-NEXT:  (array.get_u $packed-i16
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-get-u (param (ref 16) i32) (result i32)
  local.get 0
  local.get 1
  array.get_u $packed-i16
 )

 ;; CHECK:      (func $array-set (type $53) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
 ;; CHECK-NEXT:  (array.set $a2
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-set (param (ref $a2) i32 f32)
  local.get 0
  local.get 1
  local.get 2
  array.set $a2
 )

 ;; CHECK:      (func $array-len (type $54) (param $0 arrayref) (result i32)
 ;; CHECK-NEXT:  (array.len
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-len (param (ref null array)) (result i32)
  local.get 0
  array.len
 )

 ;; CHECK:      (func $array-copy (type $55) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
 ;; CHECK-NEXT:  (array.copy $a2 $a2
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $3)
 ;; CHECK-NEXT:   (local.get $4)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-copy (param (ref $a2) i32 (ref $a2) i32 i32)
  local.get 0
  local.get 1
  local.get 2
  local.get 3
  local.get 4
  array.copy $a2 $a2
 )

 ;; CHECK:      (func $array-fill (type $56) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
 ;; CHECK-NEXT:  (array.fill $a2
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $3)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-fill (param (ref $a2) i32 f32 i32)
  local.get 0
  local.get 1
  local.get 2
  local.get 3
  array.fill $a2
 )

 ;; CHECK:      (func $array-init-data (type $57) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
 ;; CHECK-NEXT:  (array.init_data $a2 $implicit-data
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $3)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-init-data (param (ref $a2) i32 i32 i32)
  local.get 0
  local.get 1
  local.get 2
  local.get 3
  array.init_data $a2 0
 )

 ;; CHECK:      (func $array-init-elem (type $58) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
 ;; CHECK-NEXT:  (array.init_elem $any-array $passive-2
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $3)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $array-init-elem (param (ref $any-array) i32 i32 i32)
  local.get 0
  local.get 1
  local.get 2
  local.get 3
  array.init_elem $any-array $passive-2
 )

 ;; CHECK:      (func $ref-as-non-null (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (ref.as_non_null
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $ref-as-non-null (param anyref)
  local.get 0
  ref.as_non_null
  drop
 )

 ;; CHECK:      (func $any-convert-extern (type $59) (param $0 externref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (extern.internalize
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $any-convert-extern (param externref)
  local.get 0
  extern.internalize
  drop
 )

 ;; CHECK:      (func $extern-convert-any (type $8) (param $0 anyref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (extern.externalize
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $extern-convert-any (param anyref)
  local.get 0
  extern.externalize
  drop
 )

 ;; CHECK:      (func $string-new (type $60) (param $0 i32) (param $1 i32) (result stringref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.new_utf8_try
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.new_wtf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.new_lossy_utf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (string.new_wtf16
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-new (param i32 i32) (result stringref)
  local.get 0
  local.get 1
  string.new_utf8_try
  drop
  local.get 0
  local.get 1
  string.new_wtf8 0
  drop
  local.get 0
  local.get 1
  string.new_lossy_utf8 $mem
  drop
  local.get 0
  local.get 1
  string.new_wtf16
 )

 ;; CHECK:      (func $string-new-gc (type $61) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
 ;; CHECK-NEXT:  (string.new_utf8_array
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-new-gc (param (ref $packed-i8) i32 i32) (result stringref)
  local.get 0
  local.get 1
  local.get 2
  string.new_utf8_array
 )

 ;; CHECK:      (func $string-new-code-point (type $62) (param $0 i32) (result stringref)
 ;; CHECK-NEXT:  (string.from_code_point
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-new-code-point (param i32) (result stringref)
  local.get 0
  string.from_code_point
 )

 ;; CHECK:      (func $string-const (type $63) (result (ref string))
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.const "foobar")
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (string.const "\00\00\00")
 ;; CHECK-NEXT: )
 (func $string-const (result (ref string))
  string.const "foobar"
  drop
  string.const "\00\00\00"
 )

 ;; CHECK:      (func $string-measure (type $21) (param $0 stringref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.measure_wtf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.measure_utf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.measure_wtf16
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.is_usv_sequence
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-measure (param stringref)
  local.get 0
  string.measure_wtf8
  drop
  local.get 0
  string.measure_utf8
  drop
  local.get 0
  string.measure_wtf16
  drop
  local.get 0
  string.is_usv_sequence
  drop
 )

 ;; CHECK:      (func $string-hash (type $64) (param $0 stringref) (result i32)
 ;; CHECK-NEXT:  (string.hash
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-hash (param stringref) (result i32)
  local.get 0
  string.hash
 )

 ;; CHECK:      (func $stringview-length (type $65) (param $0 stringview_wtf16) (result i32)
 ;; CHECK-NEXT:  (stringview_wtf16.length
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $stringview-length (param stringview_wtf16) (result i32)
  local.get 0
  stringview_wtf16.length
 )

 ;; CHECK:      (func $string-encode (type $21) (param $0 stringref)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.encode_wtf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.encode_lossy_utf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.encode_utf8
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 2)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (string.encode_wtf16
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (i32.const 3)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-encode (param stringref)
  local.get 0
  i32.const 0
  string.encode_wtf8
  drop
  local.get 0
  i32.const 1
  string.encode_lossy_utf8 0
  drop
  local.get 0
  i32.const 2
  string.encode_utf8 $mem
  drop
  local.get 0
  i32.const 3
  string.encode_wtf16
  drop
 )

 ;; CHECK:      (func $string-encode-gc (type $66) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
 ;; CHECK-NEXT:  (string.encode_wtf8_array
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-encode-gc (param stringref (ref $packed-i8) i32) (result i32)
  local.get 0
  local.get 1
  local.get 2
  string.encode_wtf8_array
 )

 ;; CHECK:      (func $string-concat (type $67) (param $0 stringref) (param $1 stringref) (result (ref string))
 ;; CHECK-NEXT:  (string.concat
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-concat (param stringref stringref) (result (ref string))
  local.get 0
  local.get 1
  string.concat
 )

 ;; CHECK:      (func $string-eq (type $22) (param $0 stringref) (param $1 stringref) (result i32)
 ;; CHECK-NEXT:  (string.eq
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-eq (param stringref stringref) (result i32)
  local.get 0
  local.get 1
  string.eq
 )

 ;; CHECK:      (func $string-compare (type $22) (param $0 stringref) (param $1 stringref) (result i32)
 ;; CHECK-NEXT:  (string.compare
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-compare (param stringref stringref) (result i32)
  local.get 0
  local.get 1
  string.compare
 )

 ;; CHECK:      (func $string-as-wtf8 (type $68) (param $0 stringref) (result stringview_wtf8)
 ;; CHECK-NEXT:  (string.as_wtf8
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-as-wtf8 (param stringref) (result stringview_wtf8)
  local.get 0
  string.as_wtf8
 )

 ;; CHECK:      (func $string-as-wtf16 (type $69) (param $0 stringref) (result (ref stringview_wtf16))
 ;; CHECK-NEXT:  (string.as_wtf16
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-as-wtf16 (param stringref) (result (ref stringview_wtf16))
  local.get 0
  string.as_wtf16
 )

 ;; CHECK:      (func $string-as-iter (type $70) (param $0 stringref) (result stringview_iter)
 ;; CHECK-NEXT:  (string.as_iter
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-as-iter (param stringref) (result stringview_iter)
  local.get 0
  string.as_iter
 )

 ;; CHECK:      (func $string-advance (type $71) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
 ;; CHECK-NEXT:  (stringview_wtf8.advance
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-advance (param (ref stringview_wtf8) i32 i32) (result i32)
  local.get 0
  local.get 1
  local.get 2
  stringview_wtf8.advance
 )

 ;; CHECK:      (func $string-get (type $72) (param $0 stringview_wtf16) (param $1 i32) (result i32)
 ;; CHECK-NEXT:  (stringview_wtf16.get_codeunit
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-get (param stringview_wtf16 i32) (result i32)
  local.get 0
  local.get 1
  stringview_wtf16.get_codeunit
 )

 ;; CHECK:      (func $string-iter-next (type $73) (param $0 stringview_iter) (result i32)
 ;; CHECK-NEXT:  (stringview_iter.next
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-iter-next (param stringview_iter) (result i32)
  local.get 0
  stringview_iter.next
 )

 ;; CHECK:      (func $string-iter-advance (type $74) (param $0 stringview_iter) (param $1 i32) (result i32)
 ;; CHECK-NEXT:  (stringview_iter.advance
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-iter-advance (param (ref null stringview_iter) i32) (result i32)
  local.get 0
  local.get 1
  stringview_iter.advance
 )

 ;; CHECK:      (func $string-iter-rewind (type $75) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
 ;; CHECK-NEXT:  (stringview_iter.rewind
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-iter-rewind (param (ref stringview_iter) i32) (result i32)
  local.get 0
  local.get 1
  stringview_iter.rewind
 )

 ;; CHECK:      (func $string-slice (type $76) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (stringview_wtf8.slice
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:    (local.get $3)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (stringview_wtf16.slice
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:    (local.get $3)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-slice (param stringview_wtf8 stringview_wtf16 i32 i32)
  local.get 0
  local.get 2
  local.get 3
  stringview_wtf8.slice
  drop
  local.get 1
  local.get 2
  local.get 3
  stringview_wtf16.slice
  drop
 )

 ;; CHECK:      (func $string-iter-slice (type $77) (param $0 stringview_iter) (param $1 i32) (result (ref string))
 ;; CHECK-NEXT:  (stringview_iter.slice
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $string-iter-slice (param stringview_iter i32) (result (ref string))
  local.get 0
  local.get 1
  stringview_iter.slice
 )

 ;; CHECK:      (func $call (type $23) (param $0 i32) (param $1 i64) (result f32)
 ;; CHECK-NEXT:  (call $call
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $call (param i32 i64) (result f32)
  local.get 0
  local.get 1
  call $call
 )

 ;; CHECK:      (func $return_call (type $23) (param $0 i32) (param $1 i64) (result f32)
 ;; CHECK-NEXT:  (return_call $return_call
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return_call (param i32 i64) (result f32)
  local.get 0
  local.get 1
  return_call $return_call
 )

 ;; CHECK:      (func $call-indirect (type $9) (param $0 i32) (param $1 i64) (param $2 v128)
 ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (call_indirect $timport$0 (type $24)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $call-indirect (param i32 i64 v128)
  local.get 0
  call_indirect
  local.get 0
  call_indirect 2
  local.get 0
  call_indirect $funcs
  local.get 0
  call_indirect (type $void)
  local.get 0
  call_indirect 2 (type $void) (param) (result)
  local.get 0
  call_indirect $funcs (type $void)
  local.get 0
  call_indirect (param) (result)
  local.get 0
  call_indirect 2 (param) (result)
  local.get 0
  call_indirect $funcs (param) (result)
  local.get 1
  local.get 2
  local.get 0
  call_indirect (param i64 v128) (result v128)
  drop
 )

 ;; CHECK:      (func $call-indirect-folded (type $9) (param $0 i32) (param $1 i64) (param $2 v128)
 ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (drop
 ;; CHECK-NEXT:   (call_indirect $timport$0 (type $24)
 ;; CHECK-NEXT:    (local.get $1)
 ;; CHECK-NEXT:    (local.get $2)
 ;; CHECK-NEXT:    (local.get $0)
 ;; CHECK-NEXT:   )
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $call-indirect-folded (param i32 i64 v128)
  (call_indirect
   (local.get 0)
  )
  (call_indirect 2
   (local.get 0)
  )
  (call_indirect $funcs
   (local.get 0)
  )
  (call_indirect (type $void)
   (local.get 0)
  )
  (call_indirect 2 (type $void) (param) (result)
   (local.get 0)
  )
  (call_indirect $funcs (type $void)
   (local.get 0)
  )
  (call_indirect (param) (result)
   (local.get 0)
  )
  (call_indirect 2 (param) (result)
   (local.get 0)
  )
  (call_indirect $funcs (param) (result)
   (local.get 0)
  )
  (drop
   (call_indirect (param i64 v128) (result v128)
    (local.get 1)
    (local.get 2)
    (local.get 0)
   )
  )
 )

 ;; CHECK:      (func $return-call-indirect (type $9) (param $0 i32) (param $1 i64) (param $2 v128)
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $25)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return-call-indirect (param i32 i64 v128)
  local.get 0
  return_call_indirect
  local.get 0
  return_call_indirect 2
  local.get 0
  return_call_indirect $funcs
  local.get 0
  return_call_indirect (type $void)
  local.get 0
  return_call_indirect 2 (type $void) (param) (result)
  local.get 0
  return_call_indirect $funcs (type $void)
  local.get 0
  return_call_indirect (param) (result)
  local.get 0
  return_call_indirect 2 (param) (result)
  local.get 0
  return_call_indirect $funcs (param) (result)
  local.get 1
  local.get 2
  local.get 0
  return_call_indirect (param i64 v128)
 )

 ;; CHECK:      (func $return-call-indirect-folded (type $9) (param $0 i32) (param $1 i64) (param $2 v128)
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $25)
 ;; CHECK-NEXT:   (local.get $1)
 ;; CHECK-NEXT:   (local.get $2)
 ;; CHECK-NEXT:   (local.get $0)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
 (func $return-call-indirect-folded (param i32 i64 v128)
  (return_call_indirect
   (local.get 0)
  )
  (return_call_indirect 2
   (local.get 0)
  )
  (return_call_indirect $funcs
   (local.get 0)
  )
  (return_call_indirect (type $void)
   (local.get 0)
  )
  (return_call_indirect 2 (type $void) (param) (result)
   (local.get 0)
  )
  (return_call_indirect $funcs (type $void)
   (local.get 0)
  )
  (return_call_indirect (param) (result)
   (local.get 0)
  )
  (return_call_indirect 2 (param) (result)
   (local.get 0)
  )
  (return_call_indirect $funcs (param) (result)
   (local.get 0)
  )
  (return_call_indirect (param i64 v128)
   (local.get 1)
   (local.get 2)
   (local.get 0)
  )
 )

 ;; CHECK:      (func $use-types (type $88) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany))
 ;; CHECK-NEXT:  (nop)
 ;; CHECK-NEXT: )
 (func $use-types
  (param (ref $s0))
  (param (ref $s1))
  (param (ref $s2))
  (param (ref $s3))
  (param (ref $s4))
  (param (ref $s5))
  (param (ref $s6))
  (param (ref $s7))
  (param (ref $s8))
  (param (ref $a0))
  (param (ref $a1))
  (param (ref $a2))
  (param (ref $a3))
  (param (ref $subvoid))
  (param (ref $submany))
 )
)