diff --git a/ml-proto/host/lexer.mll b/ml-proto/host/lexer.mll
index 4774d41d93..61b4d62f7d 100644
--- a/ml-proto/host/lexer.mll
+++ b/ml-proto/host/lexer.mll
@@ -88,18 +88,19 @@ let escape = ['n''t''\\''\'''\"']
 let character =
   [^'"''\\''\x00'-'\x1f''\x7f'] | '\\'escape | '\\'hexdigit hexdigit
 
-let sign = ('+' | '-')?
-let num = sign digit+
-let hexnum = sign "0x" hexdigit+
-let int = num | hexnum
+let sign = ('+' | '-')
+let num = digit+
+let hexnum = "0x" hexdigit+
+let nat = num | hexnum
+let int = sign nat
 let float =
-    (num '.' digit*)
-  | num ('.' digit*)? ('e' | 'E') num
-  | sign "0x" hexdigit+ '.'? hexdigit* 'p' sign digit+
-  | sign "inf"
-  | sign "infinity"
-  | sign "nan"
-  | sign "nan:0x" hexdigit+
+    sign? num '.' digit*
+  | sign? num ('.' digit*)? ('e' | 'E') sign? num
+  | sign? "0x" hexdigit+ '.'? hexdigit* 'p' sign? digit+
+  | sign? "inf"
+  | sign? "infinity"
+  | sign? "nan"
+  | sign? "nan:0x" hexdigit+
 let text = '"' character* '"'
 let name = '$' (letter | digit | '_' | tick | symbol)+
 
@@ -115,6 +116,7 @@ let mem_size = "8" | "16" | "32"
 rule token = parse
   | "(" { LPAR }
   | ")" { RPAR }
+  | nat as s { NAT s }
   | int as s { INT s }
   | float as s { FLOAT s }
   | text as s { TEXT (text s) }
diff --git a/ml-proto/host/parser.mly b/ml-proto/host/parser.mly
index c79b54fe6f..25f50b14fd 100644
--- a/ml-proto/host/parser.mly
+++ b/ml-proto/host/parser.mly
@@ -124,7 +124,7 @@ let implicit_decl c t at =
 
 %}
 
-%token INT FLOAT TEXT VAR VALUE_TYPE LPAR RPAR
+%token NAT INT FLOAT TEXT VAR VALUE_TYPE LPAR RPAR
 %token NOP BLOCK IF THEN ELSE SELECT LOOP BR BR_IF BR_TABLE
 %token CALL CALL_IMPORT CALL_INDIRECT RETURN
 %token GET_LOCAL SET_LOCAL LOAD STORE OFFSET ALIGN
@@ -136,6 +136,7 @@ let implicit_decl c t at =
 %token INPUT OUTPUT
 %token EOF
 
+%token<string> NAT
 %token<string> INT
 %token<string> FLOAT
 %token<string> TEXT
@@ -190,12 +191,13 @@ func_type :
 /* Expressions */
 
 literal :
+  | NAT { $1 @@ at () }
   | INT { $1 @@ at () }
   | FLOAT { $1 @@ at () }
 ;
 
 var :
-  | INT { let at = at () in fun c lookup -> int_of_string $1 @@ at }
+  | NAT { let at = at () in fun c lookup -> int_of_string $1 @@ at }
   | VAR { let at = at () in fun c lookup -> lookup c ($1 @@ at) @@ at }
 ;
 var_list :
@@ -345,7 +347,7 @@ start :
     { fun c -> $3 c func }
 
 segment :
-  | LPAR SEGMENT INT text_list RPAR
+  | LPAR SEGMENT NAT text_list RPAR
     { {Memory.addr = Int64.of_string $3; Memory.data = $4} @@ at () }
 ;
 segment_list :
@@ -354,10 +356,10 @@ segment_list :
 ;
 
 memory :
-  | LPAR MEMORY INT INT segment_list RPAR
+  | LPAR MEMORY NAT NAT segment_list RPAR
     { {min = Int64.of_string $3; max = Int64.of_string $4; segments = $5}
         @@ at () }
-  | LPAR MEMORY INT segment_list RPAR
+  | LPAR MEMORY NAT segment_list RPAR
     { {min = Int64.of_string $3; max = Int64.of_string $3; segments = $4}
         @@ at () }
 ;
diff --git a/ml-proto/spec/check.ml b/ml-proto/spec/check.ml
index a74ed444f4..a64b88f7df 100644
--- a/ml-proto/spec/check.ml
+++ b/ml-proto/spec/check.ml
@@ -225,9 +225,9 @@ let rec check_expr c et e =
     check_type out et e.at
 
 and check_exprs c ts es at =
+  require (List.length ts = List.length es) at "arity mismatch";
   let ets = List.map (fun x -> Some x) ts in
-  try List.iter2 (check_expr c) ets es
-  with Invalid_argument _ -> error at "arity mismatch"
+  List.iter2 (check_expr c) ets es
 
 and check_expr_opt c et eo at =
   match eo with
diff --git a/ml-proto/test/br.wast b/ml-proto/test/br.wast
index b8a6f9390c..a370f88af7 100644
--- a/ml-proto/test/br.wast
+++ b/ml-proto/test/br.wast
@@ -362,4 +362,3 @@
   (module (func $large-label (br 0x100000001)))
   "unknown label"
 )
-
diff --git a/ml-proto/test/call.wast b/ml-proto/test/call.wast
new file mode 100644
index 0000000000..b903a8d056
--- /dev/null
+++ b/ml-proto/test/call.wast
@@ -0,0 +1,255 @@
+;; Test `call` operator
+
+(module
+  ;; Auxiliary definitions
+  (func $const-i32 (result i32) (i32.const 0x132))
+  (func $const-i64 (result i64) (i64.const 0x164))
+  (func $const-f32 (result f32) (f32.const 0xf32))
+  (func $const-f64 (result f64) (f64.const 0xf64))
+
+  (func $id-i32 (param i32) (result i32) (get_local 0))
+  (func $id-i64 (param i64) (result i64) (get_local 0))
+  (func $id-f32 (param f32) (result f32) (get_local 0))
+  (func $id-f64 (param f64) (result f64) (get_local 0))
+
+  (func $f32-i32 (param f32 i32) (result i32) (get_local 1))
+  (func $i32-i64 (param i32 i64) (result i64) (get_local 1))
+  (func $f64-f32 (param f64 f32) (result f32) (get_local 1))
+  (func $i64-f64 (param i64 f64) (result f64) (get_local 1))
+
+  ;; Typing
+
+  (func "type-i32" (result i32) (call $const-i32))
+  (func "type-i64" (result i64) (call $const-i64))
+  (func "type-f32" (result f32) (call $const-f32))
+  (func "type-f64" (result f64) (call $const-f64))
+
+  (func "type-first-i32" (result i32) (call $id-i32 (i32.const 32)))
+  (func "type-first-i64" (result i64) (call $id-i64 (i64.const 64)))
+  (func "type-first-f32" (result f32) (call $id-f32 (f32.const 1.32)))
+  (func "type-first-f64" (result f64) (call $id-f64 (f64.const 1.64)))
+
+  (func "type-second-i32" (result i32)
+    (call $f32-i32 (f32.const 32.1) (i32.const 32))
+  )
+  (func "type-second-i64" (result i64)
+    (call $i32-i64 (i32.const 32) (i64.const 64))
+  )
+  (func "type-second-f32" (result f32)
+    (call $f64-f32 (f64.const 64) (f32.const 32))
+  )
+  (func "type-second-f64" (result f64)
+    (call $i64-f64 (i64.const 64) (f64.const 64.1))
+  )
+
+  ;; Recursion
+
+  (func "fac" $fac (param i64) (result i64)
+    (if (i64.eqz (get_local 0))
+      (i64.const 1)
+      (i64.mul (get_local 0) (call $fac (i64.sub (get_local 0) (i64.const 1))))
+    )
+  )
+
+  (func "fac-acc" $fac-acc (param i64 i64) (result i64)
+    (if (i64.eqz (get_local 0))
+      (get_local 1)
+      (call $fac-acc
+        (i64.sub (get_local 0) (i64.const 1))
+        (i64.mul (get_local 0) (get_local 1))
+      )
+    )
+  )
+
+  (func "fib" $fib (param i64) (result i64)
+    (if (i64.le_u (get_local 0) (i64.const 1))
+      (i64.const 1)
+      (i64.add
+        (call $fib (i64.sub (get_local 0) (i64.const 2)))
+        (call $fib (i64.sub (get_local 0) (i64.const 1)))
+      )
+    )
+  )
+
+  (func "even" $even (param i64) (result i32)
+    (if (i64.eqz (get_local 0))
+      (i32.const 44)
+      (call $odd (i64.sub (get_local 0) (i64.const 1)))
+    )
+  )
+  (func "odd" $odd (param i64) (result i32)
+    (if (i64.eqz (get_local 0))
+      (i32.const 99)
+      (call $even (i64.sub (get_local 0) (i64.const 1)))
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func "runaway" $runaway (call $runaway))
+
+  (func "mutual-runaway" $mutual-runaway1 (call $mutual-runaway2))
+  (func $mutual-runaway2 (call $mutual-runaway1))
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i32.const 44))
+
+(assert_trap (invoke "runaway") "call stack exhausted")
+(assert_trap (invoke "mutual-runaway") "call stack exhausted")
+
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (func $type-void-vs-num (i32.eqz (call 1)))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-num-vs-num (i32.eqz (call 1)))
+    (func (result i64) (i64.const 1))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $arity-0-vs-1 (call 1))
+    (func (param i32))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-0-vs-2 (call 1))
+    (func (param f64 i32))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-1-vs-0 (call 1 (i32.const 1)))
+    (func)
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1)))
+    (func)
+  )
+  "arity mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $arity-nop-first (call 1 (nop) (i32.const 1) (i32.const 2)))
+    (func (param i32 i32))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-nop-mid (call 1 (i32.const 1) (nop) (i32.const 2)))
+    (func (param i32 i32))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-nop-last (call 1 (i32.const 1) (i32.const 2) (nop)))
+    (func (param i32 i32))
+  )
+  "arity mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-first-void-vs-num (call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-void-vs-num (call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+
+
+;; Unbound function
+
+(assert_invalid
+  (module (func $unbound-func (call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $large-func (call 10001232130000)))
+  "unknown function"
+)
diff --git a/ml-proto/test/call_indirect.wast b/ml-proto/test/call_indirect.wast
new file mode 100644
index 0000000000..cf71b54e43
--- /dev/null
+++ b/ml-proto/test/call_indirect.wast
@@ -0,0 +1,334 @@
+;; Test `call_indirect` operator
+
+(module
+  ;; Auxiliary definitions
+  (type $proc (func))
+  (type $out-i32 (func (result i32)))
+  (type $out-i64 (func (result i64)))
+  (type $out-f32 (func (result f32)))
+  (type $out-f64 (func (result f64)))
+  (type $over-i32 (func (param i32) (result i32)))
+  (type $over-i64 (func (param i64) (result i64)))
+  (type $over-f32 (func (param f32) (result f32)))
+  (type $over-f64 (func (param f64) (result f64)))
+  (type $f32-i32 (func (param f32 i32) (result i32)))
+  (type $i32-i64 (func (param i32 i64) (result i64)))
+  (type $f64-f32 (func (param f64 f32) (result f32)))
+  (type $i64-f64 (func (param i64 f64) (result f64)))
+
+  (func $const-i32 (type $out-i32) (i32.const 0x132))
+  (func $const-i64 (type $out-i64) (i64.const 0x164))
+  (func $const-f32 (type $out-f32) (f32.const 0xf32))
+  (func $const-f64 (type $out-f64) (f64.const 0xf64))
+
+  (func $id-i32 (type $over-i32) (get_local 0))
+  (func $id-i64 (type $over-i64) (get_local 0))
+  (func $id-f32 (type $over-f32) (get_local 0))
+  (func $id-f64 (type $over-f64) (get_local 0))
+
+  (func $f32-i32 (type $f32-i32) (get_local 1))
+  (func $i32-i64 (type $i32-i64) (get_local 1))
+  (func $f64-f32 (type $f64-f32) (get_local 1))
+  (func $i64-f64 (type $i64-f64) (get_local 1))
+
+  (table
+    $const-i32 $const-i64 $const-f32 $const-f64
+    $id-i32 $id-i64 $id-f32 $id-f64
+    $f32-i32 $i32-i64 $f64-f32 $i64-f64
+    $fac $fib $even $odd
+    $runaway $mutual-runaway1 $mutual-runaway2
+  )
+
+  ;; Typing
+
+  (func "type-i32" (result i32) (call_indirect $out-i32 (i32.const 0)))
+  (func "type-i64" (result i64) (call_indirect $out-i64 (i32.const 1)))
+  (func "type-f32" (result f32) (call_indirect $out-f32 (i32.const 2)))
+  (func "type-f64" (result f64) (call_indirect $out-f64 (i32.const 3)))
+
+  (func "type-index" (result i64)
+    (call_indirect $over-i64 (i32.const 5) (i64.const 100))
+  )
+
+  (func "type-first-i32" (result i32)
+    (call_indirect $over-i32 (i32.const 4) (i32.const 32))
+  )
+  (func "type-first-i64" (result i64)
+    (call_indirect $over-i64 (i32.const 5) (i64.const 64))
+  )
+  (func "type-first-f32" (result f32)
+    (call_indirect $over-f32 (i32.const 6) (f32.const 1.32))
+  )
+  (func "type-first-f64" (result f64)
+    (call_indirect $over-f64 (i32.const 7) (f64.const 1.64))
+  )
+
+  (func "type-second-i32" (result i32)
+    (call_indirect $f32-i32 (i32.const 8) (f32.const 32.1) (i32.const 32))
+  )
+  (func "type-second-i64" (result i64)
+    (call_indirect $i32-i64 (i32.const 9) (i32.const 32) (i64.const 64))
+  )
+  (func "type-second-f32" (result f32)
+    (call_indirect $f64-f32 (i32.const 10) (f64.const 64) (f32.const 32))
+  )
+  (func "type-second-f64" (result f64)
+    (call_indirect $i64-f64 (i32.const 11) (i64.const 64) (f64.const 64.1))
+  )
+
+  ;; Dispatch
+
+  (func "dispatch" (param i32 i64) (result i64)
+    (call_indirect $over-i64 (get_local 0) (get_local 1))
+  )
+
+  ;; Recursion
+
+  (func "fac" $fac (param i64) (result i64)
+    (if (i64.eqz (get_local 0))
+      (i64.const 1)
+      (i64.mul
+        (get_local 0)
+        (call_indirect $over-i64 (i32.const 12)
+          (i64.sub (get_local 0) (i64.const 1))
+        )
+      )
+    )
+  )
+
+  (func "fib" $fib (param i64) (result i64)
+    (if (i64.le_u (get_local 0) (i64.const 1))
+      (i64.const 1)
+      (i64.add
+        (call_indirect $over-i64 (i32.const 13)
+          (i64.sub (get_local 0) (i64.const 2))
+        )
+        (call_indirect $over-i64 (i32.const 13)
+          (i64.sub (get_local 0) (i64.const 1))
+        )
+      )
+    )
+  )
+
+  (func "even" $even (param i32) (result i32)
+    (if (i32.eqz (get_local 0))
+      (i32.const 44)
+      (call_indirect $over-i32 (i32.const 15)
+        (i32.sub (get_local 0) (i32.const 1))
+      )
+    )
+  )
+  (func "odd" $odd (param i32) (result i32)
+    (if (i32.eqz (get_local 0))
+      (i32.const 99)
+      (call_indirect $over-i32 (i32.const 14)
+        (i32.sub (get_local 0) (i32.const 1))
+      )
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func "runaway" $runaway (call_indirect $proc (i32.const 16)))
+
+  (func "mutual-runaway" $mutual-runaway1 (call_indirect $proc (i32.const 18)))
+  (func $mutual-runaway2 (call_indirect $proc (i32.const 17)))
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-index") (i64.const 100))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
+(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
+(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8))
+(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call signature mismatch")
+(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call signature mismatch")
+(assert_trap (invoke "dispatch" (i32.const 20) (i64.const 2)) "undefined table index")
+(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined table index")
+(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined table index")
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 77)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 77)) (i32.const 44))
+
+(assert_trap (invoke "runaway") "call stack exhausted")
+(assert_trap (invoke "mutual-runaway") "call stack exhausted")
+
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (type (func))
+    (func $type-void-vs-num (i32.eqz (call_indirect 0 (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (result i64)))
+    (func $type-num-vs-num (i32.eqz (call_indirect 0 (i32.const 0))))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (func $arity-0-vs-1 (call_indirect 0 (i32.const 0)))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (func $arity-0-vs-2 (call_indirect 0 (i32.const 0)))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (type (func))
+    (func $arity-1-vs-0 (call_indirect 0 (i32.const 0) (i32.const 1)))
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (type (func))
+    (func $arity-2-vs-0
+      (call_indirect 0 (i32.const 0) (f64.const 2) (i32.const 1))
+    )
+  )
+  "arity mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (func $arity-nop-first
+      (call_indirect 0 (i32.const 0) (nop) (i32.const 1) (i32.const 2))
+    )
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (func $arity-nop-mid
+      (call_indirect 0 (i32.const 0) (i32.const 1) (nop) (i32.const 2))
+    )
+  )
+  "arity mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (func $arity-nop-last
+      (call_indirect 0 (i32.const 0) (i32.const 1) (i32.const 2) (nop))
+    )
+  )
+  "arity mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (func $type-func-void-vs-i32 (call_indirect 0 (nop) (i32.const 1)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (func $type-func-num-vs-i32 (call_indirect 0 (i64.const 1) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (func $type-first-void-vs-num
+      (call_indirect 0 (i32.const 0) (nop) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (func $type-second-void-vs-num
+      (call_indirect 0 (i32.const 0) (i32.const 1) (nop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 f64)))
+    (func $type-first-num-vs-num
+      (call_indirect 0 (i32.const 0) (f64.const 1) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (func $type-second-num-vs-num
+      (call_indirect 0 (i32.const 0) (i32.const 1) (f64.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Unbound type
+
+(assert_invalid
+  (module (func $unbound-type (call_indirect 1 (i32.const 0))))
+  "unknown function type"
+)
+(assert_invalid
+  (module (func $large-type (call_indirect 10001232130000 (i32.const 0))))
+  "unknown function type"
+)
diff --git a/ml-proto/test/func.wast b/ml-proto/test/func.wast
new file mode 100644
index 0000000000..c79012bd97
--- /dev/null
+++ b/ml-proto/test/func.wast
@@ -0,0 +1,442 @@
+;; Test `func` declarations, i.e. functions
+
+(module
+  ;; Auxiliary definition
+  (type $sig (func))
+  (func $dummy)
+
+  ;; Syntax
+
+  (func)
+  (func "f")
+  (func $f)
+  (func "g" $h)
+
+  (func (local))
+  (func (local i32))
+  (func (local $x i32))
+  (func (local i32 f64 i64))
+  (func (local i32) (local f64))
+  (func (local i32 f32) (local $x i64) (local) (local i32 f64))
+
+  (func (param))
+  (func (param i32))
+  (func (param $x i32))
+  (func (param i32 f64 i64))
+  (func (param i32) (param f64))
+  (func (param i32 f32) (param $x i64) (param) (param i32 f64))
+
+  (func (result i32) (unreachable))
+
+  (func (type $sig))
+
+  (func $complex
+    (param i32 f32) (param $x i64) (param) (param i32)
+    (result i32)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+  (func $complex-sig
+    (type $sig)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+
+
+  ;; Typing of locals
+
+  (func "local-first-i32" (local i32 i32) (result i32) (get_local 0))
+  (func "local-first-i64" (local i64 i64) (result i64) (get_local 0))
+  (func "local-first-f32" (local f32 f32) (result f32) (get_local 0))
+  (func "local-first-f64" (local f64 f64) (result f64) (get_local 0))
+  (func "local-second-i32" (local i32 i32) (result i32) (get_local 1))
+  (func "local-second-i64" (local i64 i64) (result i64) (get_local 1))
+  (func "local-second-f32" (local f32 f32) (result f32) (get_local 1))
+  (func "local-second-f64" (local f64 f64) (result f64) (get_local 1))
+  (func "local-mixed" (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32) (result f64)
+    (f32.neg (get_local 0))
+    (i32.eqz (get_local 1))
+    (i64.eqz (get_local 2))
+    (i32.eqz (get_local 3))
+    (f64.neg (get_local 4))
+    (i32.eqz (get_local 5))
+    (get_local 4)
+  )
+
+  ;; Typing of parameters
+
+  (func "param-first-i32" (param i32 i32) (result i32) (get_local 0))
+  (func "param-first-i64" (param i64 i64) (result i64) (get_local 0))
+  (func "param-first-f32" (param f32 f32) (result f32) (get_local 0))
+  (func "param-first-f64" (param f64 f64) (result f64) (get_local 0))
+  (func "param-second-i32" (param i32 i32) (result i32) (get_local 1))
+  (func "param-second-i64" (param i64 i64) (result i64) (get_local 1))
+  (func "param-second-f32" (param f32 f32) (result f32) (get_local 1))
+  (func "param-second-f64" (param f64 f64) (result f64) (get_local 1))
+  (func "param-mixed" (param f32 i32) (param) (param $x i64) (param i32 f64 i32) (result f64)
+    (f32.neg (get_local 0))
+    (i32.eqz (get_local 1))
+    (i64.eqz (get_local 2))
+    (i32.eqz (get_local 3))
+    (f64.neg (get_local 4))
+    (i32.eqz (get_local 5))
+    (get_local 4)
+  )
+
+  ;; Typing of result
+
+  (func "empty")
+  (func "value-void" (call $dummy))
+  (func "value-drop" (i32.const 1))
+  (func "value-i32" (result i32) (i32.const 77))
+  (func "value-i64" (result i64) (i64.const 7777))
+  (func "value-f32" (result f32) (f32.const 77.7))
+  (func "value-f64" (result f64) (f64.const 77.77))
+  (func "value-block-void" (block (i32.const 1) (call $dummy)))
+  (func "value-block-drop" (block (call $dummy) (i32.const 1)))
+  (func "value-block-i32" (result i32) (block (call $dummy) (i32.const 77)))
+
+  (func "return-nullary" (return))
+  (func "return-void" (return (call $dummy)))
+  (func "return-drop" (return (i32.const 1)))
+  (func "return-i32" (result i32) (return (i32.const 78)))
+  (func "return-i64" (result i64) (return (i64.const 7878)))
+  (func "return-f32" (result f32) (return (f32.const 78.7)))
+  (func "return-f64" (result f64) (return (f64.const 78.78)))
+  (func "return-block-void" (return (block (i32.const 1) (call $dummy))))
+  (func "return-block-drop" (return (block (call $dummy) (i32.const 1))))
+  (func "return-block-i32" (result i32)
+    (return (block (call $dummy) (i32.const 77)))
+  )
+
+  (func "break-nullary" (br 0))
+  (func "break-void" (br 0 (call $dummy)))
+  (func "break-drop" (br 0 (i32.const 1)))
+  (func "break-i32" (result i32) (br 0 (i32.const 79)))
+  (func "break-i64" (result i64) (br 0 (i64.const 7979)))
+  (func "break-f32" (result f32) (br 0 (f32.const 79.9)))
+  (func "break-f64" (result f64) (br 0 (f64.const 79.79)))
+  (func "break-block-void" (br 0 (block (i32.const 1) (call $dummy))))
+  (func "break-block-drop" (br 0 (block (call $dummy) (i32.const 1))))
+  (func "break-block-i32" (result i32)
+    (br 0 (block (call $dummy) (i32.const 77)))
+  )
+
+  (func "break-br_if-nullary" (param i32)
+    (br_if 0 (get_local 0))
+  )
+  (func "break-br_if-void" (param i32)
+    (br_if 0 (call $dummy) (get_local 0))
+  )
+  (func "break-br_if-num" (param i32) (result i32)
+    (br_if 0 (i32.const 50) (get_local 0)) (i32.const 51)
+  )
+
+  (func "break-br_table-nullary" (param i32)
+    (br_table 0 0 0 (get_local 0))
+  )
+  (func "break-br_table-void" (param i32)
+    (br_table 0 0 (call $dummy) (get_local 0))
+  )
+  (func "break-br_table-num" (param i32) (result i32)
+    (br_table 0 0 (i32.const 50) (get_local 0)) (i32.const 51)
+  )
+  (func "break-br_table-nested-nullary" (param i32)
+    (block (br_table 0 1 0 (get_local 0)))
+  )
+  (func "break-br_table-nested-num" (param i32) (result i32)
+    (i32.add
+      (block (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51))
+      (i32.const 2)
+    )
+  )
+
+  ;; Default initialization of locals
+
+  (func "init-local-i32" (local i32) (result i32) (get_local 0))
+  (func "init-local-i64" (local i64) (result i64) (get_local 0))
+  (func "init-local-f32" (local f32) (result f32) (get_local 0))
+  (func "init-local-f64" (local f64) (result f64) (get_local 0))
+)
+
+(assert_return (invoke "local-first-i32") (i32.const 0))
+(assert_return (invoke "local-first-i64") (i64.const 0))
+(assert_return (invoke "local-first-f32") (f32.const 0))
+(assert_return (invoke "local-first-f64") (f64.const 0))
+(assert_return (invoke "local-second-i32") (i32.const 0))
+(assert_return (invoke "local-second-i64") (i64.const 0))
+(assert_return (invoke "local-second-f32") (f32.const 0))
+(assert_return (invoke "local-second-f64") (f64.const 0))
+(assert_return (invoke "local-mixed") (f64.const 0))
+
+(assert_return
+  (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)
+)
+(assert_return
+  (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)
+)
+(assert_return
+  (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)
+)
+(assert_return
+  (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)
+)
+(assert_return
+  (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)
+)
+(assert_return
+  (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)
+)
+(assert_return
+  (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)
+)
+(assert_return
+  (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)
+)
+
+(assert_return
+  (invoke "param-mixed"
+    (f32.const 1) (i32.const 2) (i64.const 3)
+    (i32.const 4) (f64.const 5.5) (i32.const 6)
+  )
+  (f64.const 5.5)
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "value-void"))
+(assert_return (invoke "value-drop"))
+(assert_return (invoke "value-i32") (i32.const 77))
+(assert_return (invoke "value-i64") (i64.const 7777))
+(assert_return (invoke "value-f32") (f32.const 77.7))
+(assert_return (invoke "value-f64") (f64.const 77.77))
+(assert_return (invoke "value-block-void"))
+(assert_return (invoke "value-block-drop"))
+(assert_return (invoke "value-block-i32") (i32.const 77))
+
+(assert_return (invoke "return-nullary"))
+(assert_return (invoke "return-void"))
+(assert_return (invoke "return-drop"))
+(assert_return (invoke "return-i32") (i32.const 78))
+(assert_return (invoke "return-i64") (i64.const 7878))
+(assert_return (invoke "return-f32") (f32.const 78.7))
+(assert_return (invoke "return-f64") (f64.const 78.78))
+(assert_return (invoke "return-block-void"))
+(assert_return (invoke "return-block-drop"))
+(assert_return (invoke "return-block-i32") (i32.const 77))
+
+(assert_return (invoke "break-nullary"))
+(assert_return (invoke "break-void"))
+(assert_return (invoke "break-drop"))
+(assert_return (invoke "break-i32") (i32.const 79))
+(assert_return (invoke "break-i64") (i64.const 7979))
+(assert_return (invoke "break-f32") (f32.const 79.9))
+(assert_return (invoke "break-f64") (f64.const 79.79))
+(assert_return (invoke "break-block-void"))
+(assert_return (invoke "break-block-drop"))
+(assert_return (invoke "break-block-i32") (i32.const 77))
+
+(assert_return (invoke "break-br_if-nullary" (i32.const 0)))
+(assert_return (invoke "break-br_if-nullary" (i32.const 2)))
+(assert_return (invoke "break-br_if-void" (i32.const 0)))
+(assert_return (invoke "break-br_if-void" (i32.const -1)))
+(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51))
+(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50))
+
+(assert_return (invoke "break-br_table-nullary" (i32.const 0)))
+(assert_return (invoke "break-br_table-nullary" (i32.const 1)))
+(assert_return (invoke "break-br_table-nullary" (i32.const 5)))
+(assert_return (invoke "break-br_table-nullary" (i32.const -1)))
+(assert_return (invoke "break-br_table-void" (i32.const 0)))
+(assert_return (invoke "break-br_table-void" (i32.const 1)))
+(assert_return (invoke "break-br_table-void" (i32.const 2)))
+(assert_return (invoke "break-br_table-void" (i32.const -100)))
+(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50))
+(assert_return (invoke "break-br_table-nested-nullary" (i32.const 0)))
+(assert_return (invoke "break-br_table-nested-nullary" (i32.const 1)))
+(assert_return (invoke "break-br_table-nested-nullary" (i32.const 3)))
+(assert_return (invoke "break-br_table-nested-nullary" (i32.const -2)))
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52)
+)
+
+(assert_return (invoke "init-local-i32") (i32.const 0))
+(assert_return (invoke "init-local-i64") (i64.const 0))
+(assert_return (invoke "init-local-f32") (f32.const 0))
+(assert_return (invoke "init-local-f64") (f64.const 0))
+
+
+;; Invalid typing of locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (local i32) (result i64) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (get_local 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (get_local 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of result
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-num (result i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result i32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-num-after-return (result i32)
+    (return (i32.const 1)) (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num-after-return (result i32)
+    (return (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-num-after-break (result i32)
+    (br 0 (i32.const 1)) (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num-after-break (result i32)
+    (br 0 (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-last-void-vs-num (result i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-num (result i32)
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-num (result i32)
+    (return (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-num (result i32)
+    (return (i64.const 1)) (return (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-second-num-vs-num (result i32)
+    (return (i32.const 1)) (return (f64.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-last-void-vs-num (result i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-num (result i32)
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-second-num-vs-num (result i32)
+    (br 0 (i32.const 1)) (br 0 (f64.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-void-vs-num (result i32)
+    (block (br 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-num (result i32)
+    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+
diff --git a/ml-proto/test/functions.wast b/ml-proto/test/functions.wast
deleted file mode 100644
index 0510582d1f..0000000000
--- a/ml-proto/test/functions.wast
+++ /dev/null
@@ -1,44 +0,0 @@
-(module
-  (func $empty)
-  (export "empty" $empty)
-
-  (func $result-nop (nop))
-  (export "result-nop" $result-nop)
-
-  (func $result-drop (i32.const 1))
-  (export "result-drop" $result-drop)
-
-  (func $result-block-nop (block (i32.const 1) (nop)))
-  (export "result-block-nop" $result-block-nop)
-
-  (func $result-block-drop (block (nop) (i32.const 1)))
-  (export "result-block-drop" $result-block-drop)
-
-  (func $return (return))
-  (export "return" $return)
-
-  (func $return-nop (return (nop)))
-  (export "return-nop" $return-nop)
-
-  (func $return-drop (return (i32.const 1)))
-  (export "return-drop" $return-drop)
-
-  (func $return-block-nop (return (block (i32.const 1) (nop))))
-  (export "return-block-nop" $return-block-nop)
-
-  (func $return-block-drop (return (block (nop) (i32.const 1))))
-  (export "return-block-drop" $return-block-drop)
-)
-
-(assert_return (invoke "empty"))
-(assert_return (invoke "result-nop"))
-(assert_return (invoke "result-drop"))
-(assert_return (invoke "result-block-nop"))
-(assert_return (invoke "result-block-drop"))
-
-(assert_return (invoke "return"))
-(assert_return (invoke "return-nop"))
-(assert_return (invoke "return-drop"))
-(assert_return (invoke "return-block-nop"))
-(assert_return (invoke "return-block-drop"))
-
diff --git a/ml-proto/test/get_local.wast b/ml-proto/test/get_local.wast
new file mode 100644
index 0000000000..e2549dd149
--- /dev/null
+++ b/ml-proto/test/get_local.wast
@@ -0,0 +1,147 @@
+;; Test `get_local` operator
+
+(module
+  ;; Typing
+
+  (func "type-local-i32" (local i32) (result i32) (get_local 0))
+  (func "type-local-i64" (local i64) (result i64) (get_local 0))
+  (func "type-local-f32" (local f32) (result f32) (get_local 0))
+  (func "type-local-f64" (local f64) (result f64) (get_local 0))
+
+  (func "type-param-i32" (param i32) (result i32) (get_local 0))
+  (func "type-param-i64" (param i64) (result i64) (get_local 0))
+  (func "type-param-f32" (param f32) (result f32) (get_local 0))
+  (func "type-param-f64" (param f64) (result f64) (get_local 0))
+
+  (func "type-mixed" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result f64)
+    (i64.eqz (get_local 0))
+    (f32.neg (get_local 1))
+    (f64.neg (get_local 2))
+    (i32.eqz (get_local 3))
+    (i32.eqz (get_local 4))
+    (f32.neg (get_local 5))
+    (i64.eqz (get_local 6))
+    (i64.eqz (get_local 7))
+    (f64.neg (get_local 8))
+  )
+
+  ;; Reading
+
+  (func "read" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result f64)
+    (set_local 5 (f32.const 5.5))
+    (set_local 6 (i64.const 6))
+    (set_local 8 (f64.const 8))
+    (f64.add
+      (f64.convert_u/i64 (get_local 0))
+      (f64.add
+        (f64.promote/f32 (get_local 1))
+        (f64.add
+          (get_local 2)
+          (f64.add
+            (f64.convert_u/i32 (get_local 3))
+            (f64.add
+              (f64.convert_s/i32 (get_local 4))
+              (f64.add
+                (f64.promote/f32 (get_local 5))
+                (f64.add
+                  (f64.convert_u/i64 (get_local 6))
+                  (f64.add
+                    (f64.convert_u/i64 (get_local 7))
+                    (get_local 8)
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 3))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 4.4))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 5.5))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (f64.const -0)
+)
+
+(assert_return
+  (invoke "read"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (local i32) (result i64) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (get_local 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (get_local 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (get_local 3)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (get_local 14324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (get_local 2)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (local i32 i64) (get_local 714324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343)))
+  "unknown local"
+)
+
diff --git a/ml-proto/test/return.wast b/ml-proto/test/return.wast
index 1539f0b31d..b5bdb1cb03 100644
--- a/ml-proto/test/return.wast
+++ b/ml-proto/test/return.wast
@@ -9,180 +9,180 @@
   (func "nullary" (return))
   (func "unary" (result f64) (return (f64.const 3.1)))
 
-  (func "first" (result i32)
+  (func "as-func-first" (result i32)
     (return (i32.const 1)) (i32.const 2)
   )
-  (func "mid" (result i32)
+  (func "as-func-mid" (result i32)
     (i32.const 1) (return (i32.const 2)) (i32.const 3)
   )
-  (func "last"
+  (func "as-func-last"
     (nop) (i32.const 1) (return)
   )
-  (func "value" (result i32)
+  (func "as-func-value" (result i32)
     (nop) (i32.const 1) (return (i32.const 3))
   )
 
-  (func "block-first"
+  (func "as-block-first"
     (block (return) (i32.const 2))
   )
-  (func "block-mid"
+  (func "as-block-mid"
     (block (i32.const 1) (return) (i32.const 2))
   )
-  (func "block-last"
+  (func "as-block-last"
     (block (nop) (i32.const 1) (return))
   )
-  (func "block-value" (result i32)
+  (func "as-block-value" (result i32)
     (block (nop) (i32.const 1) (return (i32.const 2)))
   )
 
-  (func "loop-first" (result i32)
+  (func "as-loop-first" (result i32)
     (loop (return (i32.const 3)) (i32.const 2))
   )
-  (func "loop-mid" (result i32)
+  (func "as-loop-mid" (result i32)
     (loop (i32.const 1) (return (i32.const 4)) (i32.const 2))
   )
-  (func "loop-last" (result i32)
+  (func "as-loop-last" (result i32)
     (loop (nop) (i32.const 1) (return (i32.const 5)))
   )
 
-  (func "br-value" (result i32)
+  (func "as-br-value" (result i32)
     (block (br 0 (return (i32.const 9))))
   )
 
-  (func "br_if-cond"
+  (func "as-br_if-cond"
     (block (br_if 0 (return)))
   )
-  (func "br_if-value" (result i32)
+  (func "as-br_if-value" (result i32)
     (block (br_if 0 (return (i32.const 8)) (i32.const 1)) (i32.const 7))
   )
-  (func "br_if-value-cond" (result i32)
+  (func "as-br_if-value-cond" (result i32)
     (block (br_if 0 (i32.const 6) (return (i32.const 9))) (i32.const 7))
   )
 
-  (func "br_table-index" (result i64)
+  (func "as-br_table-index" (result i64)
     (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1)
   )
-  (func "br_table-value" (result i32)
+  (func "as-br_table-value" (result i32)
     (block (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7))
   )
-  (func "br_table-value-index" (result i32)
+  (func "as-br_table-value-index" (result i32)
     (block (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7))
   )
 
-  (func "return-value" (result i64)
+  (func "as-return-value" (result i64)
     (return (return (i64.const 7)))
   )
 
-  (func "if-cond" (result i32)
+  (func "as-if-cond" (result i32)
     (if (return (i32.const 2)) (i32.const 0) (i32.const 1))
   )
-  (func "if-then" (param i32 i32) (result i32)
+  (func "as-if-then" (param i32 i32) (result i32)
     (if (get_local 0) (return (i32.const 3)) (get_local 1))
   )
-  (func "if-else" (param i32 i32) (result i32)
+  (func "as-if-else" (param i32 i32) (result i32)
     (if (get_local 0) (get_local 1) (return (i32.const 4)))
   )
 
-  (func "select-first" (param i32 i32) (result i32)
+  (func "as-select-first" (param i32 i32) (result i32)
     (select (return (i32.const 5)) (get_local 0) (get_local 1))
   )
-  (func "select-second" (param i32 i32) (result i32)
+  (func "as-select-second" (param i32 i32) (result i32)
     (select (get_local 0) (return (i32.const 6)) (get_local 1))
   )
-  (func "select-cond" (result i32)
+  (func "as-select-cond" (result i32)
     (select (i32.const 0) (i32.const 1) (return (i32.const 7)))
   )
 
   (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func "call-first" (result i32)
+  (func "as-call-first" (result i32)
     (call $f (return (i32.const 12)) (i32.const 2) (i32.const 3))
   )
-  (func "call-mid" (result i32)
+  (func "as-call-mid" (result i32)
     (call $f (i32.const 1) (return (i32.const 13)) (i32.const 3))
   )
-  (func "call-last" (result i32)
+  (func "as-call-last" (result i32)
     (call $f (i32.const 1) (i32.const 2) (return (i32.const 14)))
   )
 
   (import "spectest" "print" (param i32 i32 i32))
-  (func "call_import-first"
+  (func "as-call_import-first"
     (call_import 0 (return) (i32.const 2) (i32.const 3))
   )
-  (func "call_import-mid"
+  (func "as-call_import-mid"
     (call_import 0 (i32.const 1) (return) (i32.const 3))
   )
-  (func "call_import-last"
+  (func "as-call_import-last"
     (call_import 0 (i32.const 1) (i32.const 2) (return))
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
   (table $f)
-  (func "call_indirect-func" (result i32)
+  (func "as-call_indirect-func" (result i32)
     (call_indirect $sig (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3))
   )
-  (func "call_indirect-first" (result i32)
+  (func "as-call_indirect-first" (result i32)
     (call_indirect $sig (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3))
   )
-  (func "call_indirect-mid" (result i32)
+  (func "as-call_indirect-mid" (result i32)
     (call_indirect $sig (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3))
   )
-  (func "call_indirect-last" (result i32)
+  (func "as-call_indirect-last" (result i32)
     (call_indirect $sig (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23)))
   )
 
-  (func "set_local-value" (result i32) (local f32)
+  (func "as-set_local-value" (result i32) (local f32)
     (set_local 0 (return (i32.const 17))) (i32.const -1)
   )
 
   (memory 1)
-  (func "load-address" (result f32)
+  (func "as-load-address" (result f32)
     (f32.load (return (f32.const 1.7)))
   )
-  (func "loadN-address" (result i64)
+  (func "as-loadN-address" (result i64)
     (i64.load8_s (return (i64.const 30)))
   )
 
-  (func "store-address" (result i32)
+  (func "as-store-address" (result i32)
     (f64.store (return (i32.const 30)) (f64.const 7)) (i32.const -1)
   )
-  (func "store-value" (result i32)
+  (func "as-store-value" (result i32)
     (i64.store (i32.const 2) (return (i32.const 31))) (i32.const -1)
   )
 
-  (func "storeN-address" (result i32)
+  (func "as-storeN-address" (result i32)
     (i32.store8 (return (i32.const 32)) (i32.const 7)) (i32.const -1)
   )
-  (func "storeN-value" (result i32)
+  (func "as-storeN-value" (result i32)
     (i64.store16 (i32.const 2) (return (i32.const 33))) (i32.const -1)
   )
 
-  (func "unary-operand" (result f32)
+  (func "as-unary-operand" (result f32)
     (f32.neg (return (f32.const 3.4)))
   )
 
-  (func "binary-left" (result i32)
+  (func "as-binary-left" (result i32)
     (i32.add (return (i32.const 3)) (i32.const 10))
   )
-  (func "binary-right" (result i64)
+  (func "as-binary-right" (result i64)
     (i64.sub (i64.const 10) (return (i64.const 45)))
   )
 
-  (func "test-operand" (result i32)
+  (func "as-test-operand" (result i32)
     (i32.eqz (return (i32.const 44)))
   )
 
-  (func "compare-left" (result i32)
+  (func "as-compare-left" (result i32)
     (f64.le (return (i32.const 43)) (f64.const 10))
   )
-  (func "compare-right" (result i32)
+  (func "as-compare-right" (result i32)
     (f32.ne (f32.const 10) (return (i32.const 42)))
   )
 
-  (func "convert-operand" (result i32)
+  (func "as-convert-operand" (result i32)
     (i32.wrap/i64 (return (i32.const 41)))
   )
 
-  (func "grow_memory-size" (result i32)
+  (func "as-grow_memory-size" (result i32)
     (grow_memory (return (i32.const 40)))
   )
 )
@@ -195,93 +195,87 @@
 (assert_return (invoke "nullary"))
 (assert_return (invoke "unary") (f64.const 3.1))
 
-(assert_invalid
-  (module (func (result f64) (return)))
-  "type mismatch"
-)
+(assert_return (invoke "as-func-first") (i32.const 1))
+(assert_return (invoke "as-func-mid") (i32.const 2))
+(assert_return (invoke "as-func-last"))
+(assert_return (invoke "as-func-value") (i32.const 3))
 
-(assert_invalid
-  (module (func (result f64) (return (i64.const 1))))
-  "type mismatch"
-)
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
 
-(assert_invalid
-  (module (func (result f64) (return (f32.const 1))))
-  "type mismatch"
-)
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
 
-(assert_return (invoke "first") (i32.const 1))
-(assert_return (invoke "mid") (i32.const 2))
-(assert_return (invoke "last"))
-(assert_return (invoke "value") (i32.const 3))
+(assert_return (invoke "as-br-value") (i32.const 9))
 
-(assert_return (invoke "block-first"))
-(assert_return (invoke "block-mid"))
-(assert_return (invoke "block-last"))
-(assert_return (invoke "block-value") (i32.const 2))
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
 
-(assert_return (invoke "loop-first") (i32.const 3))
-(assert_return (invoke "loop-mid") (i32.const 4))
-(assert_return (invoke "loop-last") (i32.const 5))
+(assert_return (invoke "as-br_table-index") (i64.const 9))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
 
-(assert_return (invoke "br-value") (i32.const 9))
+(assert_return (invoke "as-return-value") (i64.const 7))
 
-(assert_return (invoke "br_if-cond"))
-(assert_return (invoke "br_if-value") (i32.const 8))
-(assert_return (invoke "br_if-value-cond") (i32.const 9))
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
 
-(assert_return (invoke "br_table-index") (i64.const 9))
-(assert_return (invoke "br_table-value") (i32.const 10))
-(assert_return (invoke "br_table-value-index") (i32.const 11))
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
 
-(assert_return (invoke "return-value") (i64.const 7))
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
 
-(assert_return (invoke "if-cond") (i32.const 2))
-(assert_return (invoke "if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
-(assert_return (invoke "if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
-(assert_return (invoke "if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
-(assert_return (invoke "if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-call_import-first"))
+(assert_return (invoke "as-call_import-mid"))
+(assert_return (invoke "as-call_import-last"))
 
-(assert_return (invoke "select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
-(assert_return (invoke "select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
-(assert_return (invoke "select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
-(assert_return (invoke "select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
-(assert_return (invoke "select-cond") (i32.const 7))
+(assert_return (invoke "as-call_indirect-func") (i32.const 20))
+(assert_return (invoke "as-call_indirect-first") (i32.const 21))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 22))
+(assert_return (invoke "as-call_indirect-last") (i32.const 23))
 
-(assert_return (invoke "call-first") (i32.const 12))
-(assert_return (invoke "call-mid") (i32.const 13))
-(assert_return (invoke "call-last") (i32.const 14))
+(assert_return (invoke "as-set_local-value") (i32.const 17))
 
-(assert_return (invoke "call_import-first"))
-(assert_return (invoke "call_import-mid"))
-(assert_return (invoke "call_import-last"))
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
 
-(assert_return (invoke "call_indirect-func") (i32.const 20))
-(assert_return (invoke "call_indirect-first") (i32.const 21))
-(assert_return (invoke "call_indirect-mid") (i32.const 22))
-(assert_return (invoke "call_indirect-last") (i32.const 23))
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
 
-(assert_return (invoke "set_local-value") (i32.const 17))
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
 
-(assert_return (invoke "load-address") (f32.const 1.7))
-(assert_return (invoke "loadN-address") (i64.const 30))
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
 
-(assert_return (invoke "store-address") (i32.const 30))
-(assert_return (invoke "store-value") (i32.const 31))
-(assert_return (invoke "storeN-address") (i32.const 32))
-(assert_return (invoke "storeN-value") (i32.const 33))
+(assert_return (invoke "as-test-operand") (i32.const 44))
 
-(assert_return (invoke "unary-operand") (f32.const 3.4))
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
 
-(assert_return (invoke "binary-left") (i32.const 3))
-(assert_return (invoke "binary-right") (i64.const 45))
+(assert_return (invoke "as-convert-operand") (i32.const 41))
 
-(assert_return (invoke "test-operand") (i32.const 44))
+(assert_return (invoke "as-grow_memory-size") (i32.const 40))
 
-(assert_return (invoke "compare-left") (i32.const 43))
-(assert_return (invoke "compare-right") (i32.const 42))
-
-(assert_return (invoke "convert-operand") (i32.const 41))
-
-(assert_return (invoke "grow_memory-size") (i32.const 40))
+(assert_invalid
+  (module (func $type-value-void-vs-num (result f64) (return)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result f64) (return (i64.const 1))))
+  "type mismatch"
+)
 
diff --git a/ml-proto/test/runaway-recursion.wast b/ml-proto/test/runaway-recursion.wast
deleted file mode 100644
index 71bccd425b..0000000000
--- a/ml-proto/test/runaway-recursion.wast
+++ /dev/null
@@ -1,17 +0,0 @@
-(module
-  ;; Implementations are required to have every call consume some abstract
-  ;; resource towards exhausting some abstract finite limit, such that
-  ;; infinitely recursive testcases reliably trap in finite time. This is
-  ;; because otherwise applications could come to depend on it on those
-  ;; implementations and be incompatible with implementations that don't do
-  ;; it (or don't do it under the same circumstances).
-  (func (call 0))
-  (export "runaway" 0)
-
-  (func $a (call $b))
-  (func $b (call $a))
-  (export "mutual_runaway" $a)
-)
-
-(assert_trap (invoke "runaway") "call stack exhausted")
-(assert_trap (invoke "mutual_runaway") "call stack exhausted")
diff --git a/ml-proto/test/set_local.wast b/ml-proto/test/set_local.wast
new file mode 100644
index 0000000000..e93960d9ea
--- /dev/null
+++ b/ml-proto/test/set_local.wast
@@ -0,0 +1,235 @@
+;; Test `set_local` operator
+
+(module
+  ;; Typing
+
+  (func "type-local-i32" (local i32) (result i32) (set_local 0 (i32.const 0)))
+  (func "type-local-i64" (local i64) (result i64) (set_local 0 (i64.const 0)))
+  (func "type-local-f32" (local f32) (result f32) (set_local 0 (f32.const 0)))
+  (func "type-local-f64" (local f64) (result f64) (set_local 0 (f64.const 0)))
+
+  (func "type-param-i32" (param i32) (result i32) (set_local 0 (i32.const 10)))
+  (func "type-param-i64" (param i64) (result i64) (set_local 0 (i64.const 11)))
+  (func "type-param-f32" (param f32) (result f32) (set_local 0 (f32.const 11.1)))
+  (func "type-param-f64" (param f64) (result f64) (set_local 0 (f64.const 12.2)))
+
+  (func "type-mixed" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
+    (i64.eqz (set_local 0 (i64.const 0)))
+    (f32.neg (set_local 1 (f32.const 0)))
+    (f64.neg (set_local 2 (f64.const 0)))
+    (i32.eqz (set_local 3 (i32.const 0)))
+    (i32.eqz (set_local 4 (i32.const 0)))
+    (f32.neg (set_local 5 (f32.const 0)))
+    (i64.eqz (set_local 6 (i64.const 0)))
+    (i64.eqz (set_local 7 (i64.const 0)))
+    (f64.neg (set_local 8 (f64.const 0)))
+  )
+
+  ;; Writing
+
+  (func "write" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result i64)
+    (set_local 1 (f32.const -0.3))
+    (set_local 3 (i32.const 40))
+    (set_local 4 (i32.const -7))
+    (set_local 5 (f32.const 5.5))
+    (set_local 6 (i64.const 6))
+    (set_local 8 (f64.const 8))
+    (i64.trunc_s/f64
+      (f64.add
+        (f64.convert_u/i64 (get_local 0))
+        (f64.add
+          (f64.promote/f32 (get_local 1))
+          (f64.add
+            (get_local 2)
+            (f64.add
+              (f64.convert_u/i32 (get_local 3))
+              (f64.add
+                (f64.convert_s/i32 (get_local 4))
+                (f64.add
+                  (f64.promote/f32 (get_local 5))
+                  (f64.add
+                    (f64.convert_u/i64 (get_local 6))
+                    (f64.add
+                      (f64.convert_u/i64 (get_local 7))
+                      (get_local 8)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; Result
+
+  (func "result" (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64) (result f64)
+    (f64.add
+      (f64.convert_u/i64 (set_local 0 (i64.const 1)))
+      (f64.add
+        (f64.promote/f32 (set_local 1 (f32.const 2)))
+        (f64.add
+          (set_local 2 (f64.const 3.3))
+          (f64.add
+            (f64.convert_u/i32 (set_local 3 (i32.const 4)))
+            (f64.add
+              (f64.convert_s/i32 (set_local 4 (i32.const 5)))
+              (f64.add
+                (f64.promote/f32 (set_local 5 (f32.const 5.5)))
+                (f64.add
+                  (f64.convert_u/i64 (set_local 6 (i64.const 6)))
+                  (f64.add
+                    (f64.convert_u/i64 (set_local 7 (i64.const 0)))
+                    (set_local 8 (f64.const 8))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 10))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 11))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "write"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (i64.const 56)
+)
+
+(assert_return
+  (invoke "result"
+    (i64.const -1) (f32.const -2) (f64.const -3.3) (i32.const -4) (i32.const -5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (local i32) (result i64) (set_local 0 (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (set_local 0 (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (set_local 1 (i64.const 0)))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-local-arg-void-vs-num (local i32) (set_local 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local i32) (set_local 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f32) (set_local 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f64 i64) (set_local 1 (f64.const 0))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-arg-void-vs-num (param i32) (set_local 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param i32) (set_local 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f32) (set_local 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f64 i64) (set_local 1 (f64.const 0))))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (get_local 3)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (get_local 14324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (get_local 2)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (local i32 i64) (get_local 714324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (set_local 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (set_local 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (set_local 1 (i64.const 0))))
+  "type mismatch"
+)
+