diff --git a/ml-proto/README.md b/ml-proto/README.md
index 5627b75618..3b4fa6736b 100644
--- a/ml-proto/README.md
+++ b/ml-proto/README.md
@@ -130,7 +130,7 @@ type expr =
   | StoreGlobal of var * expr               (* write global variable
   | Load of loadop * expr                   (* read memory address
   | Store of storeop * expr * expr          (* write memory address
-  | Const of value                          (* constant
+  | Literal of value                        (* literal value
   | Unary of unop * expr                    (* unary arithmetic operator
   | Binary of binop * expr * expr           (* binary arithmetic operator
   | Compare of relop * expr * expr          (* arithmetic comparison
@@ -182,7 +182,7 @@ expr:
   ( store_global <var> <expr> )
   ( <type>.load((8|16)_<sign>)?(/<align>)? <expr> )
   ( <type>.store(/<align>)? <expr> <expr> )
-  ( <type>.const <value> )
+  ( <type>.literal <value> )
   ( <type>.<unop> <expr> )
   ( <type>.<binop> <expr> <expr> )
   ( <type>.<relop> <expr> <expr> )
diff --git a/ml-proto/src/host/lexer.mll b/ml-proto/src/host/lexer.mll
index 3483b5803a..fa74ae2c3a 100644
--- a/ml-proto/src/host/lexer.mll
+++ b/ml-proto/src/host/lexer.mll
@@ -152,7 +152,7 @@ rule token = parse
     { STORETRUNC (truncop t sz a) }
 
   | (nxx as t)".switch" { SWITCH (value_type t) }
-  | (nxx as t)".const" { CONST (value_type t) }
+  | (nxx as t)".literal" { LITERAL (value_type t) }
 
   | (ixx as t)".clz" { UNARY (intop t Int32Op.Clz Int64Op.Clz) }
   | (ixx as t)".ctz" { UNARY (intop t Int32Op.Ctz Int64Op.Ctz) }
diff --git a/ml-proto/src/host/parser.mly b/ml-proto/src/host/parser.mly
index c671035a39..8108f8354b 100644
--- a/ml-proto/src/host/parser.mly
+++ b/ml-proto/src/host/parser.mly
@@ -38,7 +38,7 @@ let literal at s t =
     | Types.Int64Type -> Values.Int64 (I64.of_string s) @@ at
     | Types.Float32Type -> Values.Float32 (F32.of_string s) @@ at
     | Types.Float64Type -> Values.Float64 (F64.of_string s) @@ at
-  with _ -> Error.error at "constant out of range"
+  with _ -> Error.error at "literal value out of range"
 
 
 (* Symbolic variables *)
@@ -96,7 +96,7 @@ let anon_label c = {c with labels = VarMap.map ((+) 1) c.labels}
 %token NOP BLOCK IF LOOP LABEL BREAK SWITCH CASE FALLTHROUGH
 %token CALL CALLIMPORT CALLINDIRECT RETURN
 %token GETLOCAL SETLOCAL LOAD STORE
-%token CONST UNARY BINARY COMPARE CONVERT
+%token LITERAL UNARY BINARY COMPARE CONVERT
 %token FUNC PARAM RESULT LOCAL MODULE MEMORY SEGMENT IMPORT EXPORT TABLE
 %token PAGESIZE MEMORYSIZE RESIZEMEMORY
 %token ASSERTINVALID ASSERTEQ ASSERTTRAP INVOKE
@@ -107,7 +107,7 @@ let anon_label c = {c with labels = VarMap.map ((+) 1) c.labels}
 %token<string> TEXT
 %token<string> VAR
 %token<Types.value_type> TYPE
-%token<Types.value_type> CONST
+%token<Types.value_type> LITERAL
 %token<Types.value_type> SWITCH
 %token<Ast.unop> UNARY
 %token<Ast.binop> BINARY
@@ -183,7 +183,7 @@ oper :
   | STORE expr expr { fun c -> Store ($1, $2 c, $3 c) }
   | LOADEXTEND expr { fun c -> LoadExtend ($1, $2 c) }
   | STORETRUNC expr expr { fun c -> StoreTrunc ($1, $2 c, $3 c) }
-  | CONST literal { let at = at() in fun c -> Const (literal at $2 $1) }
+  | LITERAL literal { let at = at() in fun c -> Literal (literal at $2 $1) }
   | UNARY expr { fun c -> Unary ($1, $2 c) }
   | BINARY expr expr { fun c -> Binary ($1, $2 c, $3 c) }
   | COMPARE expr expr { fun c -> Compare ($1, $2 c, $3 c) }
diff --git a/ml-proto/src/spec/ast.ml b/ml-proto/src/spec/ast.ml
index 1605f68b9b..e93b76a157 100644
--- a/ml-proto/src/spec/ast.ml
+++ b/ml-proto/src/spec/ast.ml
@@ -91,7 +91,7 @@ and expr' =
   | Store of memop * expr * expr
   | LoadExtend of extendop * expr
   | StoreTrunc of truncop * expr * expr
-  | Const of literal
+  | Literal of literal
   | Unary of unop * expr
   | Binary of binop * expr * expr
   | Compare of relop * expr * expr
diff --git a/ml-proto/src/spec/check.ml b/ml-proto/src/spec/check.ml
index 1ca52be718..3be7eff4c7 100644
--- a/ml-proto/src/spec/check.ml
+++ b/ml-proto/src/spec/check.ml
@@ -188,7 +188,7 @@ let rec check_expr c et e =
     check_mem_type truncop.memop.ty truncop.sz e.at;
     check_store c et truncop.memop e1 e2 e.at
 
-  | Const v ->
+  | Literal v ->
     check_literal c et v
 
   | Unary (unop, e1) ->
diff --git a/ml-proto/src/spec/eval.ml b/ml-proto/src/spec/eval.ml
index 16eab27afa..e3d8a0c728 100644
--- a/ml-proto/src/spec/eval.ml
+++ b/ml-proto/src/spec/eval.ml
@@ -196,7 +196,7 @@ let rec eval_expr (c : config) (e : expr) =
     with exn -> memory_error e.at exn);
     None
 
-  | Const v ->
+  | Literal v ->
     Some v.it
 
   | Unary (unop, e1) ->
diff --git a/ml-proto/test/conversions.wasm b/ml-proto/test/conversions.wasm
index 0b6b08e25b..9039948a4c 100644
--- a/ml-proto/test/conversions.wasm
+++ b/ml-proto/test/conversions.wasm
@@ -75,280 +75,280 @@
   (export "i64.reinterpret_f64" $i64.reinterpret_f64)
 )
 
-(assert_eq (invoke "i64.extend_s_i32" (i32.const 0)) (i64.const 0))
-(assert_eq (invoke "i64.extend_s_i32" (i32.const 10000)) (i64.const 10000))
-(assert_eq (invoke "i64.extend_s_i32" (i32.const -10000)) (i64.const -10000))
-(assert_eq (invoke "i64.extend_s_i32" (i32.const -1)) (i64.const -1))
-(assert_eq (invoke "i64.extend_s_i32" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
-(assert_eq (invoke "i64.extend_s_i32" (i32.const 0x80000000)) (i64.const 0xffffffff80000000))
-
-(assert_eq (invoke "i64.extend_u_i32" (i32.const 0)) (i64.const 0))
-(assert_eq (invoke "i64.extend_u_i32" (i32.const 10000)) (i64.const 10000))
-(assert_eq (invoke "i64.extend_u_i32" (i32.const -10000)) (i64.const 0x00000000ffffd8f0))
-(assert_eq (invoke "i64.extend_u_i32" (i32.const -1)) (i64.const 0xffffffff))
-(assert_eq (invoke "i64.extend_u_i32" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
-(assert_eq (invoke "i64.extend_u_i32" (i32.const 0x80000000)) (i64.const 0x0000000080000000))
-
-(assert_eq (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1))
-(assert_eq (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0x80000000)) (i32.const 0x80000000))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0xffffffff7fffffff)) (i32.const 0x7fffffff))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0xffffffff00000000)) (i32.const 0x00000000))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0xfffffffeffffffff)) (i32.const 0xffffffff))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0xffffffff00000001)) (i32.const 0x00000001))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 1311768467463790320)) (i32.const 0x9abcdef0))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0x00000000ffffffff)) (i32.const 0xffffffff))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000))
-(assert_eq (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001))
-
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const 0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const 1.401298e-45)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -1.401298e-45)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const 1.0)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const 1.1)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const 1.5)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -1.0)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -1.1)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -1.5)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -1.9)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -2.0)) (i32.const -2))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const 2147483520.0)) (i32.const 2147483520))
-(assert_eq (invoke "i32.trunc_s_f32" (f32.const -2147483648.0)) (i32.const -2147483648))
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const 2147483648.0)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const -2147483904.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const -0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 1.401298e-45)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const -1.401298e-45)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 1.0)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 1.1)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 1.5)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 1.9)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 2.0)) (i32.const 2))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const 4294967040.0)) (i32.const -256))
-(assert_eq (invoke "i32.trunc_u_f32" (f32.const -0.9)) (i32.const 0))
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const 4294967296.0)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const -1.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const 0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const 4.940656e-324)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -4.940656e-324)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const 1.0)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const 1.1)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const 1.5)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -1.0)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -1.1)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -1.5)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -1.9)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -2.0)) (i32.const -2))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const 2147483647.0)) (i32.const 2147483647))
-(assert_eq (invoke "i32.trunc_s_f64" (f64.const -2147483648.0)) (i32.const -2147483648))
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const 2147483648.0)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const -2147483649.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const -0.0)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 4.940656e-324)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const -4.940656e-324)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 1.0)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 1.1)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 1.5)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 1.9)) (i32.const 1))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 2.0)) (i32.const 2))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 4294967295.0)) (i32.const -1))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const -0.9)) (i32.const 0))
-(assert_eq (invoke "i32.trunc_u_f64" (f64.const 1e8)) (i32.const 100000000))
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 4294967296.0)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const -1.0)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e16)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e30)) "runtime: integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 9223372036854775808)) "runtime: integer overflow")
-
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 1.401298e-45)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -1.401298e-45)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 1.0)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 1.1)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 1.5)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -1.0)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -1.1)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -1.5)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -1.9)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -2.0)) (i64.const -2))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
-(assert_eq (invoke "i64.trunc_s_f32" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const 9223372036854775808.0)) "runtime: integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const -9223373136366403584.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const -0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 1.401298e-45)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const -1.401298e-45)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 1.0)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 1.1)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 1.5)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 4294967296)) (i64.const 4294967296))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
-(assert_eq (invoke "i64.trunc_u_f32" (f32.const -0.9)) (i64.const 0))
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const 18446744073709551616.0)) "runtime: integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const -1.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 4.940656e-324)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -4.940656e-324)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 1.0)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 1.1)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 1.5)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -1.0)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -1.1)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -1.5)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -1.9)) (i64.const -1))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -2.0)) (i64.const -2))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
-(assert_eq (invoke "i64.trunc_s_f64" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const 9223372036854775808.0)) "runtime: integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const -9223372036854777856.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const -0.0)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 4.940656e-324)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const -4.940656e-324)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 1.0)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 1.1)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 1.5)) (i64.const 1))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 4294967295)) (i64.const 0xffffffff))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 4294967296)) (i64.const 0x100000000))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 18446744073709549568.0)) (i64.const -2048))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const -0.9)) (i64.const 0))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 1e8)) (i64.const 100000000))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 1e16)) (i64.const 10000000000000000))
-(assert_eq (invoke "i64.trunc_u_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const 18446744073709551616.0)) "runtime: integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const -1.0)) "runtime: integer overflow")
-
-(assert_eq (invoke "f32.convert_s_i32" (i32.const 1)) (f32.const 1.0))
-(assert_eq (invoke "f32.convert_s_i32" (i32.const -1)) (f32.const -1.0))
-(assert_eq (invoke "f32.convert_s_i32" (i32.const 0)) (f32.const 0.0))
-(assert_eq (invoke "f32.convert_s_i32" (i32.const 2147483647)) (f32.const 2147483647))
-(assert_eq (invoke "f32.convert_s_i32" (i32.const -2147483648)) (f32.const -2147483648))
-(assert_eq (invoke "f32.convert_s_i32" (i32.const 1234567890)) (f32.const 1234567890))
-
-(assert_eq (invoke "f32.convert_s_i64" (i64.const 1)) (f32.const 1.0))
-(assert_eq (invoke "f32.convert_s_i64" (i64.const -1)) (f32.const -1.0))
-(assert_eq (invoke "f32.convert_s_i64" (i64.const 0)) (f32.const 0.0))
-(assert_eq (invoke "f32.convert_s_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
-(assert_eq (invoke "f32.convert_s_i64" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
-(assert_eq (invoke "f32.convert_s_i64" (i64.const 314159265358979)) (f32.const 314159265358979)) ;; PI
-
-(assert_eq (invoke "f64.convert_s_i32" (i32.const 1)) (f64.const 1.0))
-(assert_eq (invoke "f64.convert_s_i32" (i32.const -1)) (f64.const -1.0))
-(assert_eq (invoke "f64.convert_s_i32" (i32.const 0)) (f64.const 0.0))
-(assert_eq (invoke "f64.convert_s_i32" (i32.const 2147483647)) (f64.const 2147483647))
-(assert_eq (invoke "f64.convert_s_i32" (i32.const -2147483648)) (f64.const -2147483648))
-(assert_eq (invoke "f64.convert_s_i32" (i32.const 987654321)) (f64.const 987654321))
-
-(assert_eq (invoke "f64.convert_s_i64" (i64.const 1)) (f64.const 1.0))
-(assert_eq (invoke "f64.convert_s_i64" (i64.const -1)) (f64.const -1.0))
-(assert_eq (invoke "f64.convert_s_i64" (i64.const 0)) (f64.const 0.0))
-(assert_eq (invoke "f64.convert_s_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
-(assert_eq (invoke "f64.convert_s_i64" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
-(assert_eq (invoke "f64.convert_s_i64" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
-
-(assert_eq (invoke "f32.convert_u_i32" (i32.const 1)) (f32.const 1.0))
-(assert_eq (invoke "f32.convert_u_i32" (i32.const 0)) (f32.const 0.0))
-(assert_eq (invoke "f32.convert_u_i32" (i32.const 2147483647)) (f32.const 2147483647))
-(assert_eq (invoke "f32.convert_u_i32" (i32.const -2147483648)) (f32.const 2147483648))
-(assert_eq (invoke "f32.convert_u_i32" (i32.const 0x12345678)) (f32.const 305419896)) ;; 0x12345678
-(assert_eq (invoke "f32.convert_u_i32" (i32.const 0xffffffff)) (f32.const 4294967296.0))
-
-(assert_eq (invoke "f32.convert_u_i64" (i64.const 1)) (f32.const 1.0))
-(assert_eq (invoke "f32.convert_u_i64" (i64.const 0)) (f32.const 0.0))
-(assert_eq (invoke "f32.convert_u_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
-(assert_eq (invoke "f32.convert_u_i64" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
-(assert_eq (invoke "f32.convert_u_i64" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
-
-(assert_eq (invoke "f64.convert_u_i32" (i32.const 1)) (f64.const 1.0))
-(assert_eq (invoke "f64.convert_u_i32" (i32.const 0)) (f64.const 0.0))
-(assert_eq (invoke "f64.convert_u_i32" (i32.const 2147483647)) (f64.const 2147483647))
-(assert_eq (invoke "f64.convert_u_i32" (i32.const -2147483648)) (f64.const 2147483648))
-(assert_eq (invoke "f64.convert_u_i32" (i32.const 0xffffffff)) (f64.const 4294967295.0))
-
-(assert_eq (invoke "f64.convert_u_i64" (i64.const 1)) (f64.const 1.0))
-(assert_eq (invoke "f64.convert_u_i64" (i64.const 0)) (f64.const 0.0))
-(assert_eq (invoke "f64.convert_u_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
-(assert_eq (invoke "f64.convert_u_i64" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
-(assert_eq (invoke "f64.convert_u_i64" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
-
-(assert_eq (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
-(assert_eq (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))
-(assert_eq (invoke "f64.promote_f32" (f32.const 1.401298e-45)) (f64.const 1.401298464324817e-45))
-(assert_eq (invoke "f64.promote_f32" (f32.const -1.401298e-45)) (f64.const -1.401298464324817e-45))
-(assert_eq (invoke "f64.promote_f32" (f32.const 1.0)) (f64.const 1.0))
-(assert_eq (invoke "f64.promote_f32" (f32.const -1.0)) (f64.const -1.0))
-(assert_eq (invoke "f64.promote_f32" (f32.const 1.4012985e-45)) (f64.const 1.401298464324817e-45))
-(assert_eq (invoke "f64.promote_f32" (f32.const -1.4012985e-45)) (f64.const -1.401298464324817e-45))
-(assert_eq (invoke "f64.promote_f32" (f32.const -3.4028235e+38)) (f64.const -3.4028234663852886e+38))
-(assert_eq (invoke "f64.promote_f32" (f32.const 3.4028235e+38)) (f64.const 3.4028234663852886e+38))
+(assert_eq (invoke "i64.extend_s_i32" (i32.literal 0)) (i64.literal 0))
+(assert_eq (invoke "i64.extend_s_i32" (i32.literal 10000)) (i64.literal 10000))
+(assert_eq (invoke "i64.extend_s_i32" (i32.literal -10000)) (i64.literal -10000))
+(assert_eq (invoke "i64.extend_s_i32" (i32.literal -1)) (i64.literal -1))
+(assert_eq (invoke "i64.extend_s_i32" (i32.literal 0x7fffffff)) (i64.literal 0x000000007fffffff))
+(assert_eq (invoke "i64.extend_s_i32" (i32.literal 0x80000000)) (i64.literal 0xffffffff80000000))
+
+(assert_eq (invoke "i64.extend_u_i32" (i32.literal 0)) (i64.literal 0))
+(assert_eq (invoke "i64.extend_u_i32" (i32.literal 10000)) (i64.literal 10000))
+(assert_eq (invoke "i64.extend_u_i32" (i32.literal -10000)) (i64.literal 0x00000000ffffd8f0))
+(assert_eq (invoke "i64.extend_u_i32" (i32.literal -1)) (i64.literal 0xffffffff))
+(assert_eq (invoke "i64.extend_u_i32" (i32.literal 0x7fffffff)) (i64.literal 0x000000007fffffff))
+(assert_eq (invoke "i64.extend_u_i32" (i32.literal 0x80000000)) (i64.literal 0x0000000080000000))
+
+(assert_eq (invoke "i32.wrap_i64" (i64.literal -1)) (i32.literal -1))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal -100000)) (i32.literal -100000))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0x80000000)) (i32.literal 0x80000000))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0xffffffff7fffffff)) (i32.literal 0x7fffffff))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0xffffffff00000000)) (i32.literal 0x00000000))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0xfffffffeffffffff)) (i32.literal 0xffffffff))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0xffffffff00000001)) (i32.literal 0x00000001))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 1311768467463790320)) (i32.literal 0x9abcdef0))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0x00000000ffffffff)) (i32.literal 0xffffffff))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0x0000000100000000)) (i32.literal 0x00000000))
+(assert_eq (invoke "i32.wrap_i64" (i64.literal 0x0000000100000001)) (i32.literal 0x00000001))
+
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal 0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal 1.401298e-45)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -1.401298e-45)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal 1.0)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal 1.1)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal 1.5)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -1.0)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -1.1)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -1.5)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -1.9)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -2.0)) (i32.literal -2))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal 2147483520.0)) (i32.literal 2147483520))
+(assert_eq (invoke "i32.trunc_s_f32" (f32.literal -2147483648.0)) (i32.literal -2147483648))
+(assert_trap (invoke "i32.trunc_s_f32" (f32.literal 2147483648.0)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_s_f32" (f32.literal -2147483904.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal -0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 1.401298e-45)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal -1.401298e-45)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 1.0)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 1.1)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 1.5)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 1.9)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 2.0)) (i32.literal 2))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 2147483648)) (i32.literal -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal 4294967040.0)) (i32.literal -256))
+(assert_eq (invoke "i32.trunc_u_f32" (f32.literal -0.9)) (i32.literal 0))
+(assert_trap (invoke "i32.trunc_u_f32" (f32.literal 4294967296.0)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_u_f32" (f32.literal -1.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal 0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal 4.940656e-324)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -4.940656e-324)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal 1.0)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal 1.1)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal 1.5)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -1.0)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -1.1)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -1.5)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -1.9)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -2.0)) (i32.literal -2))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal 2147483647.0)) (i32.literal 2147483647))
+(assert_eq (invoke "i32.trunc_s_f64" (f64.literal -2147483648.0)) (i32.literal -2147483648))
+(assert_trap (invoke "i32.trunc_s_f64" (f64.literal 2147483648.0)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_s_f64" (f64.literal -2147483649.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal -0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 4.940656e-324)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal -4.940656e-324)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 1.0)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 1.1)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 1.5)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 1.9)) (i32.literal 1))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 2.0)) (i32.literal 2))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 2147483648)) (i32.literal -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 4294967295.0)) (i32.literal -1))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal -0.9)) (i32.literal 0))
+(assert_eq (invoke "i32.trunc_u_f64" (f64.literal 1e8)) (i32.literal 100000000))
+(assert_trap (invoke "i32.trunc_u_f64" (f64.literal 4294967296.0)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.literal -1.0)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.literal 1e16)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.literal 1e30)) "runtime: integer overflow")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.literal 9223372036854775808)) "runtime: integer overflow")
+
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 1.401298e-45)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -1.401298e-45)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 1.0)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 1.1)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 1.5)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -1.0)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -1.1)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -1.5)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -1.9)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -2.0)) (i64.literal -2))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 4294967296)) (i64.literal 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -4294967296)) (i64.literal -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal 9223371487098961920.0)) (i64.literal 9223371487098961920))
+(assert_eq (invoke "i64.trunc_s_f32" (f32.literal -9223372036854775808.0)) (i64.literal -9223372036854775808))
+(assert_trap (invoke "i64.trunc_s_f32" (f32.literal 9223372036854775808.0)) "runtime: integer overflow")
+(assert_trap (invoke "i64.trunc_s_f32" (f32.literal -9223373136366403584.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal -0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 1.401298e-45)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal -1.401298e-45)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 1.0)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 1.1)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 1.5)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 4294967296)) (i64.literal 4294967296))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal 18446742974197923840.0)) (i64.literal -1099511627776))
+(assert_eq (invoke "i64.trunc_u_f32" (f32.literal -0.9)) (i64.literal 0))
+(assert_trap (invoke "i64.trunc_u_f32" (f32.literal 18446744073709551616.0)) "runtime: integer overflow")
+(assert_trap (invoke "i64.trunc_u_f32" (f32.literal -1.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 4.940656e-324)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -4.940656e-324)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 1.0)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 1.1)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 1.5)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -1.0)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -1.1)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -1.5)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -1.9)) (i64.literal -1))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -2.0)) (i64.literal -2))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 4294967296)) (i64.literal 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -4294967296)) (i64.literal -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal 9223372036854774784.0)) (i64.literal 9223372036854774784))
+(assert_eq (invoke "i64.trunc_s_f64" (f64.literal -9223372036854775808.0)) (i64.literal -9223372036854775808))
+(assert_trap (invoke "i64.trunc_s_f64" (f64.literal 9223372036854775808.0)) "runtime: integer overflow")
+(assert_trap (invoke "i64.trunc_s_f64" (f64.literal -9223372036854777856.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal -0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 4.940656e-324)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal -4.940656e-324)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 1.0)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 1.1)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 1.5)) (i64.literal 1))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 4294967295)) (i64.literal 0xffffffff))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 4294967296)) (i64.literal 0x100000000))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 18446744073709549568.0)) (i64.literal -2048))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal -0.9)) (i64.literal 0))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 1e8)) (i64.literal 100000000))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 1e16)) (i64.literal 10000000000000000))
+(assert_eq (invoke "i64.trunc_u_f64" (f64.literal 9223372036854775808)) (i64.literal -9223372036854775808))
+(assert_trap (invoke "i64.trunc_u_f64" (f64.literal 18446744073709551616.0)) "runtime: integer overflow")
+(assert_trap (invoke "i64.trunc_u_f64" (f64.literal -1.0)) "runtime: integer overflow")
+
+(assert_eq (invoke "f32.convert_s_i32" (i32.literal 1)) (f32.literal 1.0))
+(assert_eq (invoke "f32.convert_s_i32" (i32.literal -1)) (f32.literal -1.0))
+(assert_eq (invoke "f32.convert_s_i32" (i32.literal 0)) (f32.literal 0.0))
+(assert_eq (invoke "f32.convert_s_i32" (i32.literal 2147483647)) (f32.literal 2147483647))
+(assert_eq (invoke "f32.convert_s_i32" (i32.literal -2147483648)) (f32.literal -2147483648))
+(assert_eq (invoke "f32.convert_s_i32" (i32.literal 1234567890)) (f32.literal 1234567890))
+
+(assert_eq (invoke "f32.convert_s_i64" (i64.literal 1)) (f32.literal 1.0))
+(assert_eq (invoke "f32.convert_s_i64" (i64.literal -1)) (f32.literal -1.0))
+(assert_eq (invoke "f32.convert_s_i64" (i64.literal 0)) (f32.literal 0.0))
+(assert_eq (invoke "f32.convert_s_i64" (i64.literal 9223372036854775807)) (f32.literal 9223372036854775807))
+(assert_eq (invoke "f32.convert_s_i64" (i64.literal -9223372036854775808)) (f32.literal -9223372036854775808))
+(assert_eq (invoke "f32.convert_s_i64" (i64.literal 314159265358979)) (f32.literal 314159265358979)) ;; PI
+
+(assert_eq (invoke "f64.convert_s_i32" (i32.literal 1)) (f64.literal 1.0))
+(assert_eq (invoke "f64.convert_s_i32" (i32.literal -1)) (f64.literal -1.0))
+(assert_eq (invoke "f64.convert_s_i32" (i32.literal 0)) (f64.literal 0.0))
+(assert_eq (invoke "f64.convert_s_i32" (i32.literal 2147483647)) (f64.literal 2147483647))
+(assert_eq (invoke "f64.convert_s_i32" (i32.literal -2147483648)) (f64.literal -2147483648))
+(assert_eq (invoke "f64.convert_s_i32" (i32.literal 987654321)) (f64.literal 987654321))
+
+(assert_eq (invoke "f64.convert_s_i64" (i64.literal 1)) (f64.literal 1.0))
+(assert_eq (invoke "f64.convert_s_i64" (i64.literal -1)) (f64.literal -1.0))
+(assert_eq (invoke "f64.convert_s_i64" (i64.literal 0)) (f64.literal 0.0))
+(assert_eq (invoke "f64.convert_s_i64" (i64.literal 9223372036854775807)) (f64.literal 9223372036854775807))
+(assert_eq (invoke "f64.convert_s_i64" (i64.literal -9223372036854775808)) (f64.literal -9223372036854775808))
+(assert_eq (invoke "f64.convert_s_i64" (i64.literal 4669201609102990)) (f64.literal 4669201609102990)) ;; Feigenbaum
+
+(assert_eq (invoke "f32.convert_u_i32" (i32.literal 1)) (f32.literal 1.0))
+(assert_eq (invoke "f32.convert_u_i32" (i32.literal 0)) (f32.literal 0.0))
+(assert_eq (invoke "f32.convert_u_i32" (i32.literal 2147483647)) (f32.literal 2147483647))
+(assert_eq (invoke "f32.convert_u_i32" (i32.literal -2147483648)) (f32.literal 2147483648))
+(assert_eq (invoke "f32.convert_u_i32" (i32.literal 0x12345678)) (f32.literal 305419896)) ;; 0x12345678
+(assert_eq (invoke "f32.convert_u_i32" (i32.literal 0xffffffff)) (f32.literal 4294967296.0))
+
+(assert_eq (invoke "f32.convert_u_i64" (i64.literal 1)) (f32.literal 1.0))
+(assert_eq (invoke "f32.convert_u_i64" (i64.literal 0)) (f32.literal 0.0))
+(assert_eq (invoke "f32.convert_u_i64" (i64.literal 9223372036854775807)) (f32.literal 9223372036854775807))
+(assert_eq (invoke "f32.convert_u_i64" (i64.literal -9223372036854775808)) (f32.literal 9223372036854775808))
+(assert_eq (invoke "f32.convert_u_i64" (i64.literal 0xffffffffffffffff)) (f32.literal 18446744073709551616.0))
+
+(assert_eq (invoke "f64.convert_u_i32" (i32.literal 1)) (f64.literal 1.0))
+(assert_eq (invoke "f64.convert_u_i32" (i32.literal 0)) (f64.literal 0.0))
+(assert_eq (invoke "f64.convert_u_i32" (i32.literal 2147483647)) (f64.literal 2147483647))
+(assert_eq (invoke "f64.convert_u_i32" (i32.literal -2147483648)) (f64.literal 2147483648))
+(assert_eq (invoke "f64.convert_u_i32" (i32.literal 0xffffffff)) (f64.literal 4294967295.0))
+
+(assert_eq (invoke "f64.convert_u_i64" (i64.literal 1)) (f64.literal 1.0))
+(assert_eq (invoke "f64.convert_u_i64" (i64.literal 0)) (f64.literal 0.0))
+(assert_eq (invoke "f64.convert_u_i64" (i64.literal 9223372036854775807)) (f64.literal 9223372036854775807))
+(assert_eq (invoke "f64.convert_u_i64" (i64.literal -9223372036854775808)) (f64.literal 9223372036854775808))
+(assert_eq (invoke "f64.convert_u_i64" (i64.literal 0xffffffffffffffff)) (f64.literal 18446744073709551616.0))
+
+(assert_eq (invoke "f64.promote_f32" (f32.literal 0.0)) (f64.literal 0.0))
+(assert_eq (invoke "f64.promote_f32" (f32.literal -0.0)) (f64.literal -0.0))
+(assert_eq (invoke "f64.promote_f32" (f32.literal 1.401298e-45)) (f64.literal 1.401298464324817e-45))
+(assert_eq (invoke "f64.promote_f32" (f32.literal -1.401298e-45)) (f64.literal -1.401298464324817e-45))
+(assert_eq (invoke "f64.promote_f32" (f32.literal 1.0)) (f64.literal 1.0))
+(assert_eq (invoke "f64.promote_f32" (f32.literal -1.0)) (f64.literal -1.0))
+(assert_eq (invoke "f64.promote_f32" (f32.literal 1.4012985e-45)) (f64.literal 1.401298464324817e-45))
+(assert_eq (invoke "f64.promote_f32" (f32.literal -1.4012985e-45)) (f64.literal -1.401298464324817e-45))
+(assert_eq (invoke "f64.promote_f32" (f32.literal -3.4028235e+38)) (f64.literal -3.4028234663852886e+38))
+(assert_eq (invoke "f64.promote_f32" (f32.literal 3.4028235e+38)) (f64.literal 3.4028234663852886e+38))
 ;; Generated randomly by picking a random int and reinterpret it to float.
-(assert_eq (invoke "f64.promote_f32" (f32.const 1.5046328e-36)) (f64.const 1.504632769052528e-36))
+(assert_eq (invoke "f64.promote_f32" (f32.literal 1.5046328e-36)) (f64.literal 1.504632769052528e-36))
 ;; Generated randomly by picking a random float.
-(assert_eq (invoke "f64.promote_f32" (f32.const 6.6382537e+37)) (f64.const 6.6382536710104395e+37))
-
-(assert_eq (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0))
-(assert_eq (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0))
-(assert_eq (invoke "f32.demote_f64" (f64.const 4.940656e-324)) (f32.const 0.0))
-(assert_eq (invoke "f32.demote_f64" (f64.const -4.940656e-324)) (f32.const -0.0))
-(assert_eq (invoke "f32.demote_f64" (f64.const 1.0)) (f32.const 1.0))
-(assert_eq (invoke "f32.demote_f64" (f64.const -1.0)) (f32.const -1.0))
-(assert_eq (invoke "f32.demote_f64" (f64.const -1.401298464324817e-45)) (f32.const -1.4012985e-45))
-(assert_eq (invoke "f32.demote_f64" (f64.const 1.401298464324817e-45)) (f32.const 1.4012985e-45))
-(assert_eq (invoke "f32.demote_f64" (f64.const 3.402823466385289e+38)) (f32.const 3.4028235e+38))
-(assert_eq (invoke "f32.demote_f64" (f64.const -3.402823466385289e+38)) (f32.const -3.4028235e+38))
-(assert_eq (invoke "f32.demote_f64" (f64.const 1.504632769052528e-36)) (f32.const 1.5046328e-36))
-(assert_eq (invoke "f32.demote_f64" (f64.const 6.6382536710104395e+37)) (f32.const 6.6382537e+37))
-
-(assert_eq (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0))
-(assert_eq (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0))
-(assert_eq (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 1.4012984e-45))
-(assert_eq (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 1.6535997e-34))
-(assert_eq (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -1.4012984e-45))
-
-(assert_eq (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0))
-(assert_eq (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 4.94066e-324))
-(assert_eq (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
-(assert_eq (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 6.099575819077150e-315))
-(assert_eq (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -4.940656458412465e-324))
-
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const 1.401298e-45)) (i32.const 1))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const -1.401298e-45)) (i32.const 0x80000001))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const 3.4028235e+38)) (i32.const 2139095039))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const -3.4028235e+38)) (i32.const -8388609))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const 1.4012984e-45)) (i32.const 1))
-(assert_eq (invoke "i32.reinterpret_f32" (f32.const -1.4012984e-45)) (i32.const -2147483647))
-
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const 4.940656e-324)) (i64.const 1))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const -4.940656e-324)) (i64.const 0x8000000000000001))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const 1.7976931348623157e+308)) (i64.const 9218868437227405311))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const -1.7976931348623157e+308)) (i64.const -4503599627370497))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const 4.9406565e-324)) (i64.const 1))
-(assert_eq (invoke "i64.reinterpret_f64" (f64.const -4.9406565e-324)) (i64.const -9223372036854775807))
+(assert_eq (invoke "f64.promote_f32" (f32.literal 6.6382537e+37)) (f64.literal 6.6382536710104395e+37))
+
+(assert_eq (invoke "f32.demote_f64" (f64.literal 0.0)) (f32.literal 0.0))
+(assert_eq (invoke "f32.demote_f64" (f64.literal -0.0)) (f32.literal -0.0))
+(assert_eq (invoke "f32.demote_f64" (f64.literal 4.940656e-324)) (f32.literal 0.0))
+(assert_eq (invoke "f32.demote_f64" (f64.literal -4.940656e-324)) (f32.literal -0.0))
+(assert_eq (invoke "f32.demote_f64" (f64.literal 1.0)) (f32.literal 1.0))
+(assert_eq (invoke "f32.demote_f64" (f64.literal -1.0)) (f32.literal -1.0))
+(assert_eq (invoke "f32.demote_f64" (f64.literal -1.401298464324817e-45)) (f32.literal -1.4012985e-45))
+(assert_eq (invoke "f32.demote_f64" (f64.literal 1.401298464324817e-45)) (f32.literal 1.4012985e-45))
+(assert_eq (invoke "f32.demote_f64" (f64.literal 3.402823466385289e+38)) (f32.literal 3.4028235e+38))
+(assert_eq (invoke "f32.demote_f64" (f64.literal -3.402823466385289e+38)) (f32.literal -3.4028235e+38))
+(assert_eq (invoke "f32.demote_f64" (f64.literal 1.504632769052528e-36)) (f32.literal 1.5046328e-36))
+(assert_eq (invoke "f32.demote_f64" (f64.literal 6.6382536710104395e+37)) (f32.literal 6.6382537e+37))
+
+(assert_eq (invoke "f32.reinterpret_i32" (i32.literal 0)) (f32.literal 0.0))
+(assert_eq (invoke "f32.reinterpret_i32" (i32.literal 0x80000000)) (f32.literal -0.0))
+(assert_eq (invoke "f32.reinterpret_i32" (i32.literal 1)) (f32.literal 1.4012984e-45))
+(assert_eq (invoke "f32.reinterpret_i32" (i32.literal 123456789)) (f32.literal 1.6535997e-34))
+(assert_eq (invoke "f32.reinterpret_i32" (i32.literal -2147483647)) (f32.literal -1.4012984e-45))
+
+(assert_eq (invoke "f64.reinterpret_i64" (i64.literal 0)) (f64.literal 0.0))
+(assert_eq (invoke "f64.reinterpret_i64" (i64.literal 1)) (f64.literal 4.94066e-324))
+(assert_eq (invoke "f64.reinterpret_i64" (i64.literal 0x8000000000000000)) (f64.literal -0.0))
+(assert_eq (invoke "f64.reinterpret_i64" (i64.literal 1234567890)) (f64.literal 6.099575819077150e-315))
+(assert_eq (invoke "f64.reinterpret_i64" (i64.literal -9223372036854775807)) (f64.literal -4.940656458412465e-324))
+
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal 0.0)) (i32.literal 0))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal -0.0)) (i32.literal 0x80000000))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal 1.401298e-45)) (i32.literal 1))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal -1.401298e-45)) (i32.literal 0x80000001))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal 1.0)) (i32.literal 1065353216))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal 3.1415926)) (i32.literal 1078530010))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal 3.4028235e+38)) (i32.literal 2139095039))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal -3.4028235e+38)) (i32.literal -8388609))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal 1.4012984e-45)) (i32.literal 1))
+(assert_eq (invoke "i32.reinterpret_f32" (f32.literal -1.4012984e-45)) (i32.literal -2147483647))
+
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal 0.0)) (i64.literal 0))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal -0.0)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal 4.940656e-324)) (i64.literal 1))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal -4.940656e-324)) (i64.literal 0x8000000000000001))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal 1.0)) (i64.literal 4607182418800017408))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal 3.14159265358979)) (i64.literal 4614256656552045841))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal 1.7976931348623157e+308)) (i64.literal 9218868437227405311))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal -1.7976931348623157e+308)) (i64.literal -4503599627370497))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal 4.9406565e-324)) (i64.literal 1))
+(assert_eq (invoke "i64.reinterpret_f64" (f64.literal -4.9406565e-324)) (i64.literal -9223372036854775807))
diff --git a/ml-proto/test/exports.wasm b/ml-proto/test/exports.wasm
index 069888b52d..1b1ec926fe 100644
--- a/ml-proto/test/exports.wasm
+++ b/ml-proto/test/exports.wasm
@@ -1,22 +1,22 @@
-(module (func (i32.const 1)) (export "a" 0))
-(module (func (i32.const 1)) (export "a" 0) (export "b" 0))
-(module (func (i32.const 1)) (func (i32.const 2)) (export "a" 0) (export "b" 1))
+(module (func (i32.literal 1)) (export "a" 0))
+(module (func (i32.literal 1)) (export "a" 0) (export "b" 0))
+(module (func (i32.literal 1)) (func (i32.literal 2)) (export "a" 0) (export "b" 1))
 (assert_invalid
-  (module (func (i32.const 1)) (export "a" 1))
+  (module (func (i32.literal 1)) (export "a" 1))
   "unknown function 1")
 (assert_invalid
-  (module (func (i32.const 1)) (func (i32.const 2)) (export "a" 0) (export "a" 1))
+  (module (func (i32.literal 1)) (func (i32.literal 2)) (export "a" 0) (export "a" 1))
   "duplicate export name")
 (assert_invalid
-  (module (func (i32.const 1)) (export "a" 0) (export "a" 0))
+  (module (func (i32.literal 1)) (export "a" 0) (export "a" 0))
   "duplicate export name")
 
 (module
   (func $f (param $n i32) (result i32)
-    (return (i32.add (get_local $n) (i32.const 1)))
+    (return (i32.add (get_local $n) (i32.literal 1)))
   )
 
   (export "e" $f)
 )
 
-(assert_eq (invoke "e" (i32.const 42)) (i32.const 43))
+(assert_eq (invoke "e" (i32.literal 42)) (i32.literal 43))
diff --git a/ml-proto/test/fac.wasm b/ml-proto/test/fac.wasm
index cd3dd36d1e..522ab811e9 100644
--- a/ml-proto/test/fac.wasm
+++ b/ml-proto/test/fac.wasm
@@ -3,19 +3,19 @@
 (module
   ;; Recursive factorial
   (func (param i64) (result i64)
-    (if (i64.eq (get_local 0) (i64.const 0))
-      (i64.const 1)
-      (i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.const 1))))
+    (if (i64.eq (get_local 0) (i64.literal 0))
+      (i64.literal 1)
+      (i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.literal 1))))
     )
   )
 
   ;; Recursive factorial named
   (func $fac-rec (param $n i64) (result i64)
-    (if (i64.eq (get_local $n) (i64.const 0))
-      (i64.const 1)
+    (if (i64.eq (get_local $n) (i64.literal 0))
+      (i64.literal 1)
       (i64.mul
         (get_local $n)
-        (call $fac-rec (i64.sub (get_local $n) (i64.const 1)))
+        (call $fac-rec (i64.sub (get_local $n) (i64.literal 1)))
       )
     )
   )
@@ -24,15 +24,15 @@
   (func (param i64) (result i64)
     (local i64 i64)
     (set_local 1 (get_local 0))
-    (set_local 2 (i64.const 1))
+    (set_local 2 (i64.literal 1))
     (label
       (loop
         (if
-          (i64.eq (get_local 1) (i64.const 0))
+          (i64.eq (get_local 1) (i64.literal 0))
           (break 0)
           (block
             (set_local 2 (i64.mul (get_local 1) (get_local 2)))
-            (set_local 1 (i64.sub (get_local 1) (i64.const 1)))
+            (set_local 1 (i64.sub (get_local 1) (i64.literal 1)))
           )
         )
       )
@@ -45,15 +45,15 @@
     (local $i i64)
     (local $res i64)
     (set_local $i (get_local $n))
-    (set_local $res (i64.const 1))
+    (set_local $res (i64.literal 1))
     (label $done
       (loop
         (if
-          (i64.eq (get_local $i) (i64.const 0))
+          (i64.eq (get_local $i) (i64.literal 0))
           (break $done)
           (block
             (set_local $res (i64.mul (get_local $i) (get_local $res)))
-            (set_local $i (i64.sub (get_local $i) (i64.const 1)))
+            (set_local $i (i64.sub (get_local $i) (i64.literal 1)))
           )
         )
       )
@@ -67,7 +67,7 @@
   (export "fac-iter-named" $fac-iter)
 )
 
-(assert_eq (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776))
-(assert_eq (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776))
-(assert_eq (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776))
-(assert_eq (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_eq (invoke "fac-rec" (i64.literal 25)) (i64.literal 7034535277573963776))
+(assert_eq (invoke "fac-iter" (i64.literal 25)) (i64.literal 7034535277573963776))
+(assert_eq (invoke "fac-rec-named" (i64.literal 25)) (i64.literal 7034535277573963776))
+(assert_eq (invoke "fac-iter-named" (i64.literal 25)) (i64.literal 7034535277573963776))
diff --git a/ml-proto/test/float32.wasm b/ml-proto/test/float32.wasm
index 3abe1cd1e3..7468866c7d 100644
--- a/ml-proto/test/float32.wasm
+++ b/ml-proto/test/float32.wasm
@@ -23,42 +23,42 @@
 
 (assert_eq
   (invoke "eq_float32"
-    (f32.add (f32.const 1.1234567890) (f32.const 1.2345e-10))
-    (f32.const 1.123456789)
+    (f32.add (f32.literal 1.1234567890) (f32.literal 1.2345e-10))
+    (f32.literal 1.123456789)
   )
-  (i32.const 1)
+  (i32.literal 1)
 )
 
 (assert_eq
   (invoke "eq_float64"
-    (f64.add (f64.const 1.1234567890) (f64.const 1.2345e-10))
-    (f64.const 1.123456789)
+    (f64.add (f64.literal 1.1234567890) (f64.literal 1.2345e-10))
+    (f64.literal 1.123456789)
   )
-  (i32.const 0)
+  (i32.literal 0)
 )
 
 (assert_eq
   (invoke "eq_float32"
-    (f32.mul (f32.const 1e20) (f32.const 1e20))
-    (f32.mul (f32.const 1e25) (f32.const 1e25))
+    (f32.mul (f32.literal 1e20) (f32.literal 1e20))
+    (f32.mul (f32.literal 1e25) (f32.literal 1e25))
   )
-  (i32.const 1)
+  (i32.literal 1)
 )
 
 (assert_eq
   (invoke "eq_float64"
-    (f64.mul (f64.const 1e20) (f64.const 1e20))
-    (f64.mul (f64.const 1e25) (f64.const 1e25))
+    (f64.mul (f64.literal 1e20) (f64.literal 1e20))
+    (f64.mul (f64.literal 1e25) (f64.literal 1e25))
   )
-  (i32.const 0)
+  (i32.literal 0)
 )
 
 (assert_eq
-  (invoke "div_float32" (f32.const 1.123456789) (f32.const 100))
-  (f32.const 0.011234568432)
+  (invoke "div_float32" (f32.literal 1.123456789) (f32.literal 100))
+  (f32.literal 0.011234568432)
 )
 
 (assert_eq
-  (invoke "div_float64" (f64.const 1.123456789) (f64.const 100))
-  (f64.const 0.01123456789)
+  (invoke "div_float64" (f64.literal 1.123456789) (f64.literal 100))
+  (f64.literal 0.01123456789)
 )
diff --git a/ml-proto/test/forward.wasm b/ml-proto/test/forward.wasm
index 811884ff9b..dcfdaf0f38 100644
--- a/ml-proto/test/forward.wasm
+++ b/ml-proto/test/forward.wasm
@@ -5,21 +5,21 @@
   (export "odd" $odd)
 
   (func $even (param $n i32) (result i32)
-    (if (i32.eq (get_local $n) (i32.const 0))
-      (i32.const 1)
-      (call $odd (i32.sub (get_local $n) (i32.const 1)))
+    (if (i32.eq (get_local $n) (i32.literal 0))
+      (i32.literal 1)
+      (call $odd (i32.sub (get_local $n) (i32.literal 1)))
     )
   )
 
   (func $odd (param $n i32) (result i32)
-    (if (i32.eq (get_local $n) (i32.const 0))
-      (i32.const 0)
-      (call $even (i32.sub (get_local $n) (i32.const 1)))
+    (if (i32.eq (get_local $n) (i32.literal 0))
+      (i32.literal 0)
+      (call $even (i32.sub (get_local $n) (i32.literal 1)))
     )
   )
 )
 
-(assert_eq (invoke "even" (i32.const 13)) (i32.const 0))
-(assert_eq (invoke "even" (i32.const 20)) (i32.const 1))
-(assert_eq (invoke "odd" (i32.const 13)) (i32.const 1))
-(assert_eq (invoke "odd" (i32.const 20)) (i32.const 0))
+(assert_eq (invoke "even" (i32.literal 13)) (i32.literal 0))
+(assert_eq (invoke "even" (i32.literal 20)) (i32.literal 1))
+(assert_eq (invoke "odd" (i32.literal 13)) (i32.literal 1))
+(assert_eq (invoke "odd" (i32.literal 20)) (i32.literal 0))
diff --git a/ml-proto/test/hexnum.wasm b/ml-proto/test/hexnum.wasm
index 403d11de74..b108d34a07 100644
--- a/ml-proto/test/hexnum.wasm
+++ b/ml-proto/test/hexnum.wasm
@@ -1,26 +1,26 @@
 (module
   (func $test32 (result i32)
-    (return (i32.const 0x0bAdD00D))
+    (return (i32.literal 0x0bAdD00D))
   )
 
   (func $max32 (result i32)
-    (return (i32.const 0xffffffff))
+    (return (i32.literal 0xffffffff))
   )
 
   (func $neg32 (result i32)
-    (return (i32.const -0x7fffffff))
+    (return (i32.literal -0x7fffffff))
   )
 
   (func $test64 (result i64)
-    (return (i64.const 0x0CABBA6E0ba66a6e))
+    (return (i64.literal 0x0CABBA6E0ba66a6e))
   )
 
   (func $max64 (result i64)
-    (return (i64.const 0xffffffffffffffff))
+    (return (i64.literal 0xffffffffffffffff))
   )
 
   (func $neg64 (result i64)
-    (return (i64.const -0x7fffffffffffffff))
+    (return (i64.literal -0x7fffffffffffffff))
   )
 
   (export "test32" $test32)
@@ -31,9 +31,9 @@
   (export "neg64" $neg64)
 )
 
-(assert_eq (invoke "test32") (i32.const 195940365))
-(assert_eq (invoke "max32") (i32.const -1))
-(assert_eq (invoke "neg32") (i32.const -2147483647))
-(assert_eq (invoke "test64") (i64.const 913028331277281902))
-(assert_eq (invoke "max64") (i64.const -1))
-(assert_eq (invoke "neg64") (i64.const -9223372036854775807))
+(assert_eq (invoke "test32") (i32.literal 195940365))
+(assert_eq (invoke "max32") (i32.literal -1))
+(assert_eq (invoke "neg32") (i32.literal -2147483647))
+(assert_eq (invoke "test64") (i64.literal 913028331277281902))
+(assert_eq (invoke "max64") (i64.literal -1))
+(assert_eq (invoke "neg64") (i64.literal -9223372036854775807))
diff --git a/ml-proto/test/i32.wasm b/ml-proto/test/i32.wasm
index fc23ac869b..00f03dff48 100644
--- a/ml-proto/test/i32.wasm
+++ b/ml-proto/test/i32.wasm
@@ -56,335 +56,335 @@
   (export "ge_u" $ge_u)
 )
 
-(assert_eq (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2))
-(assert_eq (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000))
-(assert_eq (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff))
-(assert_eq (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000))
+(assert_eq (invoke "add" (i32.literal 1) (i32.literal 1)) (i32.literal 2))
+(assert_eq (invoke "add" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "add" (i32.literal 0x7fffffff) (i32.literal 1)) (i32.literal 0x80000000))
+(assert_eq (invoke "add" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0x7fffffff))
+(assert_eq (invoke "add" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "add" (i32.literal 0x3fffffff) (i32.literal 1)) (i32.literal 0x40000000))
 
-(assert_eq (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000))
-(assert_eq (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff))
-(assert_eq (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000))
+(assert_eq (invoke "sub" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "sub" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "sub" (i32.literal 0x7fffffff) (i32.literal -1)) (i32.literal 0x80000000))
+(assert_eq (invoke "sub" (i32.literal 0x80000000) (i32.literal 1)) (i32.literal 0x7fffffff))
+(assert_eq (invoke "sub" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "sub" (i32.literal 0x3fffffff) (i32.literal -1)) (i32.literal 0x40000000))
 
-(assert_eq (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0))
-(assert_eq (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
-(assert_eq (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001))
-(assert_eq (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470))
+(assert_eq (invoke "mul" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "mul" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "mul" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "mul" (i32.literal 0x10000000) (i32.literal 4096)) (i32.literal 0))
+(assert_eq (invoke "mul" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "mul" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0x80000000))
+(assert_eq (invoke "mul" (i32.literal 0x7fffffff) (i32.literal -1)) (i32.literal 0x80000001))
+(assert_eq (invoke "mul" (i32.literal 0x01234567) (i32.literal 0x76543210)) (i32.literal 0x358e7470))
 
-(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "runtime: integer overflow")
-(assert_eq (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000))
-(assert_eq (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65))
-(assert_eq (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2))
-(assert_eq (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2))
-(assert_eq (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2))
-(assert_eq (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2))
-(assert_eq (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2))
-(assert_eq (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2))
-(assert_eq (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2))
-(assert_eq (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2))
-(assert_eq (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2))
-(assert_eq (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2))
+(assert_trap (invoke "div_s" (i32.literal 1) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "div_s" (i32.literal 0) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "div_s" (i32.literal 0x80000000) (i32.literal -1)) "runtime: integer overflow")
+(assert_eq (invoke "div_s" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "div_s" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "div_s" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "div_s" (i32.literal 0x80000000) (i32.literal 2)) (i32.literal 0xc0000000))
+(assert_eq (invoke "div_s" (i32.literal 0x80000001) (i32.literal 1000)) (i32.literal 0xffdf3b65))
+(assert_eq (invoke "div_s" (i32.literal 5) (i32.literal 2)) (i32.literal 2))
+(assert_eq (invoke "div_s" (i32.literal -5) (i32.literal 2)) (i32.literal -2))
+(assert_eq (invoke "div_s" (i32.literal 5) (i32.literal -2)) (i32.literal -2))
+(assert_eq (invoke "div_s" (i32.literal -5) (i32.literal -2)) (i32.literal 2))
+(assert_eq (invoke "div_s" (i32.literal 7) (i32.literal 3)) (i32.literal 2))
+(assert_eq (invoke "div_s" (i32.literal -7) (i32.literal 3)) (i32.literal -2))
+(assert_eq (invoke "div_s" (i32.literal 7) (i32.literal -3)) (i32.literal -2))
+(assert_eq (invoke "div_s" (i32.literal -7) (i32.literal -3)) (i32.literal 2))
+(assert_eq (invoke "div_s" (i32.literal 11) (i32.literal 5)) (i32.literal 2))
+(assert_eq (invoke "div_s" (i32.literal 17) (i32.literal 7)) (i32.literal 2))
 
-(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "runtime: integer divide by zero")
-(assert_eq (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000))
-(assert_eq (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef))
-(assert_eq (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b))
-(assert_eq (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2))
-(assert_eq (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd))
-(assert_eq (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0))
-(assert_eq (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0))
-(assert_eq (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2))
-(assert_eq (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2))
-(assert_eq (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2))
+(assert_trap (invoke "div_u" (i32.literal 1) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "div_u" (i32.literal 0) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_eq (invoke "div_u" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "div_u" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "div_u" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "div_u" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "div_u" (i32.literal 0x80000000) (i32.literal 2)) (i32.literal 0x40000000))
+(assert_eq (invoke "div_u" (i32.literal 0x8ff00ff0) (i32.literal 0x10001)) (i32.literal 0x8fef))
+(assert_eq (invoke "div_u" (i32.literal 0x80000001) (i32.literal 1000)) (i32.literal 0x20c49b))
+(assert_eq (invoke "div_u" (i32.literal 5) (i32.literal 2)) (i32.literal 2))
+(assert_eq (invoke "div_u" (i32.literal -5) (i32.literal 2)) (i32.literal 0x7ffffffd))
+(assert_eq (invoke "div_u" (i32.literal 5) (i32.literal -2)) (i32.literal 0))
+(assert_eq (invoke "div_u" (i32.literal -5) (i32.literal -2)) (i32.literal 0))
+(assert_eq (invoke "div_u" (i32.literal 7) (i32.literal 3)) (i32.literal 2))
+(assert_eq (invoke "div_u" (i32.literal 11) (i32.literal 5)) (i32.literal 2))
+(assert_eq (invoke "div_u" (i32.literal 17) (i32.literal 7)) (i32.literal 2))
 
-(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "runtime: integer divide by zero")
-(assert_eq (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
-(assert_eq (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647))
-(assert_eq (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1))
-(assert_eq (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1))
-(assert_eq (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1))
-(assert_eq (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1))
-(assert_eq (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1))
-(assert_eq (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1))
-(assert_eq (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1))
-(assert_eq (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1))
-(assert_eq (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1))
-(assert_eq (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3))
+(assert_trap (invoke "rem_s" (i32.literal 1) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "rem_s" (i32.literal 0) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_eq (invoke "rem_s" (i32.literal 0x7fffffff) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "rem_s" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "rem_s" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "rem_s" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "rem_s" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "rem_s" (i32.literal 0x80000000) (i32.literal 2)) (i32.literal 0))
+(assert_eq (invoke "rem_s" (i32.literal 0x80000001) (i32.literal 1000)) (i32.literal -647))
+(assert_eq (invoke "rem_s" (i32.literal 5) (i32.literal 2)) (i32.literal 1))
+(assert_eq (invoke "rem_s" (i32.literal -5) (i32.literal 2)) (i32.literal -1))
+(assert_eq (invoke "rem_s" (i32.literal 5) (i32.literal -2)) (i32.literal 1))
+(assert_eq (invoke "rem_s" (i32.literal -5) (i32.literal -2)) (i32.literal -1))
+(assert_eq (invoke "rem_s" (i32.literal 7) (i32.literal 3)) (i32.literal 1))
+(assert_eq (invoke "rem_s" (i32.literal -7) (i32.literal 3)) (i32.literal -1))
+(assert_eq (invoke "rem_s" (i32.literal 7) (i32.literal -3)) (i32.literal 1))
+(assert_eq (invoke "rem_s" (i32.literal -7) (i32.literal -3)) (i32.literal -1))
+(assert_eq (invoke "rem_s" (i32.literal 11) (i32.literal 5)) (i32.literal 1))
+(assert_eq (invoke "rem_s" (i32.literal 17) (i32.literal 7)) (i32.literal 3))
 
-(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "runtime: integer divide by zero")
-(assert_eq (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
-(assert_eq (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
-(assert_eq (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001))
-(assert_eq (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649))
-(assert_eq (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1))
-(assert_eq (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1))
-(assert_eq (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5))
-(assert_eq (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5))
-(assert_eq (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1))
-(assert_eq (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1))
-(assert_eq (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3))
+(assert_trap (invoke "rem_u" (i32.literal 1) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "rem_u" (i32.literal 0) (i32.literal 0)) "runtime: integer divide by zero")
+(assert_eq (invoke "rem_u" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "rem_u" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "rem_u" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "rem_u" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0x80000000))
+(assert_eq (invoke "rem_u" (i32.literal 0x80000000) (i32.literal 2)) (i32.literal 0))
+(assert_eq (invoke "rem_u" (i32.literal 0x8ff00ff0) (i32.literal 0x10001)) (i32.literal 0x8001))
+(assert_eq (invoke "rem_u" (i32.literal 0x80000001) (i32.literal 1000)) (i32.literal 649))
+(assert_eq (invoke "rem_u" (i32.literal 5) (i32.literal 2)) (i32.literal 1))
+(assert_eq (invoke "rem_u" (i32.literal -5) (i32.literal 2)) (i32.literal 1))
+(assert_eq (invoke "rem_u" (i32.literal 5) (i32.literal -2)) (i32.literal 5))
+(assert_eq (invoke "rem_u" (i32.literal -5) (i32.literal -2)) (i32.literal -5))
+(assert_eq (invoke "rem_u" (i32.literal 7) (i32.literal 3)) (i32.literal 1))
+(assert_eq (invoke "rem_u" (i32.literal 11) (i32.literal 5)) (i32.literal 1))
+(assert_eq (invoke "rem_u" (i32.literal 17) (i32.literal 7)) (i32.literal 3))
 
-(assert_eq (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff))
-(assert_eq (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0))
-(assert_eq (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
+(assert_eq (invoke "and" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "and" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "and" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "and" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "and" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "and" (i32.literal 0x7fffffff) (i32.literal -1)) (i32.literal 0x7fffffff))
+(assert_eq (invoke "and" (i32.literal 0xf0f0ffff) (i32.literal 0xfffff0f0)) (i32.literal 0xf0f0f0f0))
+(assert_eq (invoke "and" (i32.literal 0xffffffff) (i32.literal 0xffffffff)) (i32.literal 0xffffffff))
 
-(assert_eq (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
-(assert_eq (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
-(assert_eq (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff))
-(assert_eq (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
+(assert_eq (invoke "or" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "or" (i32.literal 0) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "or" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "or" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "or" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal -1))
+(assert_eq (invoke "or" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0x80000000))
+(assert_eq (invoke "or" (i32.literal 0xf0f0ffff) (i32.literal 0xfffff0f0)) (i32.literal 0xffffffff))
+(assert_eq (invoke "or" (i32.literal 0xffffffff) (i32.literal 0xffffffff)) (i32.literal 0xffffffff))
 
-(assert_eq (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
-(assert_eq (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
-(assert_eq (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff))
-(assert_eq (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
-(assert_eq (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f))
-(assert_eq (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0))
+(assert_eq (invoke "xor" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "xor" (i32.literal 0) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "xor" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "xor" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "xor" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal -1))
+(assert_eq (invoke "xor" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0x80000000))
+(assert_eq (invoke "xor" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 0x7fffffff))
+(assert_eq (invoke "xor" (i32.literal -1) (i32.literal 0x7fffffff)) (i32.literal 0x80000000))
+(assert_eq (invoke "xor" (i32.literal 0xf0f0ffff) (i32.literal 0xfffff0f0)) (i32.literal 0x0f0f0f0f))
+(assert_eq (invoke "xor" (i32.literal 0xffffffff) (i32.literal 0xffffffff)) (i32.literal 0))
 
-(assert_eq (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2))
-(assert_eq (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe))
-(assert_eq (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe))
-(assert_eq (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000))
-(assert_eq (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
-(assert_eq (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 0))
-(assert_eq (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 0))
-(assert_eq (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal 1)) (i32.literal 2))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "shl" (i32.literal 0x7fffffff) (i32.literal 1)) (i32.literal 0xfffffffe))
+(assert_eq (invoke "shl" (i32.literal 0xffffffff) (i32.literal 1)) (i32.literal 0xfffffffe))
+(assert_eq (invoke "shl" (i32.literal 0x80000000) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "shl" (i32.literal 0x40000000) (i32.literal 1)) (i32.literal 0x80000000))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal 31)) (i32.literal 0x80000000))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal 32)) (i32.literal 0))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal 33)) (i32.literal 0))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "shl" (i32.literal 1) (i32.literal 0x7fffffff)) (i32.literal 0))
 
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1))
-(assert_eq (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
-(assert_eq (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000))
-(assert_eq (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 0))
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0))
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1))
-(assert_eq (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1))
-(assert_eq (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1))
-(assert_eq (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1))
-(assert_eq (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1))
-(assert_eq (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "shr_s" (i32.literal -1) (i32.literal 1)) (i32.literal -1))
+(assert_eq (invoke "shr_s" (i32.literal 0x7fffffff) (i32.literal 1)) (i32.literal 0x3fffffff))
+(assert_eq (invoke "shr_s" (i32.literal 0x80000000) (i32.literal 1)) (i32.literal 0xc0000000))
+(assert_eq (invoke "shr_s" (i32.literal 0x40000000) (i32.literal 1)) (i32.literal 0x20000000))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal 32)) (i32.literal 0))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal 33)) (i32.literal 0))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "shr_s" (i32.literal 1) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "shr_s" (i32.literal 0x80000000) (i32.literal 31)) (i32.literal -1))
+(assert_eq (invoke "shr_s" (i32.literal -1) (i32.literal 32)) (i32.literal -1))
+(assert_eq (invoke "shr_s" (i32.literal -1) (i32.literal 33)) (i32.literal -1))
+(assert_eq (invoke "shr_s" (i32.literal -1) (i32.literal -1)) (i32.literal -1))
+(assert_eq (invoke "shr_s" (i32.literal -1) (i32.literal 0x7fffffff)) (i32.literal -1))
+(assert_eq (invoke "shr_s" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal -1))
 
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff))
-(assert_eq (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
-(assert_eq (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000))
-(assert_eq (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
-(assert_eq (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "shr_u" (i32.literal -1) (i32.literal 1)) (i32.literal 0x7fffffff))
+(assert_eq (invoke "shr_u" (i32.literal 0x7fffffff) (i32.literal 1)) (i32.literal 0x3fffffff))
+(assert_eq (invoke "shr_u" (i32.literal 0x80000000) (i32.literal 1)) (i32.literal 0x40000000))
+(assert_eq (invoke "shr_u" (i32.literal 0x40000000) (i32.literal 1)) (i32.literal 0x20000000))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal 32)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal 33)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal 1) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal 0x80000000) (i32.literal 31)) (i32.literal 1))
+(assert_eq (invoke "shr_u" (i32.literal -1) (i32.literal 32)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal -1) (i32.literal 33)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal -1) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "shr_u" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 0))
 
-(assert_eq (invoke "clz" (i32.const 0xffffffff)) (i32.const 0))
-(assert_eq (invoke "clz" (i32.const 0)) (i32.const 32))
-(assert_eq (invoke "clz" (i32.const 0x00008000)) (i32.const 16))
-(assert_eq (invoke "clz" (i32.const 0xff)) (i32.const 24))
-(assert_eq (invoke "clz" (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "clz" (i32.const 1)) (i32.const 31))
-(assert_eq (invoke "clz" (i32.const 2)) (i32.const 30))
+(assert_eq (invoke "clz" (i32.literal 0xffffffff)) (i32.literal 0))
+(assert_eq (invoke "clz" (i32.literal 0)) (i32.literal 32))
+(assert_eq (invoke "clz" (i32.literal 0x00008000)) (i32.literal 16))
+(assert_eq (invoke "clz" (i32.literal 0xff)) (i32.literal 24))
+(assert_eq (invoke "clz" (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "clz" (i32.literal 1)) (i32.literal 31))
+(assert_eq (invoke "clz" (i32.literal 2)) (i32.literal 30))
 
-(assert_eq (invoke "ctz" (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "ctz" (i32.const 0)) (i32.const 32))
-(assert_eq (invoke "ctz" (i32.const 0x00008000)) (i32.const 15))
-(assert_eq (invoke "ctz" (i32.const 0x00010000)) (i32.const 16))
-(assert_eq (invoke "ctz" (i32.const 0x80000000)) (i32.const 31))
+(assert_eq (invoke "ctz" (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ctz" (i32.literal 0)) (i32.literal 32))
+(assert_eq (invoke "ctz" (i32.literal 0x00008000)) (i32.literal 15))
+(assert_eq (invoke "ctz" (i32.literal 0x00010000)) (i32.literal 16))
+(assert_eq (invoke "ctz" (i32.literal 0x80000000)) (i32.literal 31))
 
-(assert_eq (invoke "popcnt" (i32.const -1)) (i32.const 32))
-(assert_eq (invoke "popcnt" (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1))
+(assert_eq (invoke "popcnt" (i32.literal -1)) (i32.literal 32))
+(assert_eq (invoke "popcnt" (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "popcnt" (i32.literal 0x00008000)) (i32.literal 1))
 
-(assert_eq (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "eq" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "eq" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_eq (invoke "eq" (i32.literal 0) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "eq" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "eq" (i32.literal -1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "eq" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "eq" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "eq" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "eq" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "eq" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "eq" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "eq" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 0))
 
-(assert_eq (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_eq (invoke "ne" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "ne" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ne" (i32.literal -1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ne" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "ne" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "ne" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ne" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ne" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ne" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "ne" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 1))
 
-(assert_eq (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+(assert_eq (invoke "lt_s" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal -1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal 0) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 0))
 
-(assert_eq (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+(assert_eq (invoke "lt_u" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal -1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 0) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "lt_u" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "lt_u" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "lt_u" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 1))
 
-(assert_eq (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+(assert_eq (invoke "le_s" (i32.literal 0) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal -1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "le_s" (i32.literal 0) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "le_s" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "le_s" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 0))
 
-(assert_eq (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+(assert_eq (invoke "le_u" (i32.literal 0) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal -1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal 1) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i32.literal 0) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 1))
 
-(assert_eq (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+(assert_eq (invoke "gt_s" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal -1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "gt_s" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "gt_s" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "gt_s" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 1))
 
-(assert_eq (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+(assert_eq (invoke "gt_u" (i32.literal 0) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal 1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal -1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal -1) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 0))
 
-(assert_eq (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+(assert_eq (invoke "ge_s" (i32.literal 0) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal -1) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 1))
 
-(assert_eq (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_eq (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_eq (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_eq (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+(assert_eq (invoke "ge_u" (i32.literal 0) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal -1) (i32.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 0x80000000) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 0x7fffffff) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal -1) (i32.literal -1)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 1) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 0) (i32.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ge_u" (i32.literal 0x80000000) (i32.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 0) (i32.literal 0x80000000)) (i32.literal 0))
+(assert_eq (invoke "ge_u" (i32.literal 0x80000000) (i32.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ge_u" (i32.literal -1) (i32.literal 0x80000000)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 0x80000000) (i32.literal 0x7fffffff)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i32.literal 0x7fffffff) (i32.literal 0x80000000)) (i32.literal 0))
diff --git a/ml-proto/test/i64.wasm b/ml-proto/test/i64.wasm
index 044ec4a262..9fa10844f0 100644
--- a/ml-proto/test/i64.wasm
+++ b/ml-proto/test/i64.wasm
@@ -56,336 +56,336 @@
   (export "ge_u" $ge_u)
 )
 
-(assert_eq (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_eq (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
-(assert_eq (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_eq (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
+(assert_eq (invoke "add" (i64.literal 1) (i64.literal 1)) (i64.literal 2))
+(assert_eq (invoke "add" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "add" (i64.literal 0x7fffffffffffffff) (i64.literal 1)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "add" (i64.literal 0x8000000000000000) (i64.literal -1)) (i64.literal 0x7fffffffffffffff))
+(assert_eq (invoke "add" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i64.literal 0))
+(assert_eq (invoke "add" (i64.literal 0x3fffffff) (i64.literal 1)) (i64.literal 0x40000000))
 
-(assert_eq (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
-(assert_eq (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_eq (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
+(assert_eq (invoke "sub" (i64.literal 1) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "sub" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "sub" (i64.literal 0x7fffffffffffffff) (i64.literal -1)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "sub" (i64.literal 0x8000000000000000) (i64.literal 1)) (i64.literal 0x7fffffffffffffff))
+(assert_eq (invoke "sub" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i64.literal 0))
+(assert_eq (invoke "sub" (i64.literal 0x3fffffff) (i64.literal -1)) (i64.literal 0x40000000))
 
-(assert_eq (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_eq (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
-(assert_eq (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
-(assert_eq (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
+(assert_eq (invoke "mul" (i64.literal 1) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "mul" (i64.literal 1) (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "mul" (i64.literal -1) (i64.literal -1)) (i64.literal 1))
+(assert_eq (invoke "mul" (i64.literal 0x1000000000000000) (i64.literal 4096)) (i64.literal 0))
+(assert_eq (invoke "mul" (i64.literal 0x8000000000000000) (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "mul" (i64.literal 0x8000000000000000) (i64.literal -1)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "mul" (i64.literal 0x7fffffffffffffff) (i64.literal -1)) (i64.literal 0x8000000000000001))
+(assert_eq (invoke "mul" (i64.literal 0x0123456789abcdef) (i64.literal 0xfedcba9876543210)) (i64.literal 0x2236d88fe5618cf0))
 
-(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "runtime: integer overflow")
-(assert_eq (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_eq (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
-(assert_eq (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
-(assert_eq (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
-(assert_eq (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
-(assert_eq (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
-(assert_eq (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
-(assert_eq (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
-(assert_eq (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
-(assert_eq (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
-(assert_eq (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
-(assert_eq (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
-(assert_eq (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
+(assert_trap (invoke "div_s" (i64.literal 1) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "div_s" (i64.literal 0) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "div_s" (i64.literal 0x8000000000000000) (i64.literal -1)) "runtime: integer overflow")
+(assert_eq (invoke "div_s" (i64.literal 1) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "div_s" (i64.literal 0) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "div_s" (i64.literal -1) (i64.literal -1)) (i64.literal 1))
+(assert_eq (invoke "div_s" (i64.literal 0x8000000000000000) (i64.literal 2)) (i64.literal 0xc000000000000000))
+(assert_eq (invoke "div_s" (i64.literal 0x8000000000000001) (i64.literal 1000)) (i64.literal 0xffdf3b645a1cac09))
+(assert_eq (invoke "div_s" (i64.literal 5) (i64.literal 2)) (i64.literal 2))
+(assert_eq (invoke "div_s" (i64.literal -5) (i64.literal 2)) (i64.literal -2))
+(assert_eq (invoke "div_s" (i64.literal 5) (i64.literal -2)) (i64.literal -2))
+(assert_eq (invoke "div_s" (i64.literal -5) (i64.literal -2)) (i64.literal 2))
+(assert_eq (invoke "div_s" (i64.literal 7) (i64.literal 3)) (i64.literal 2))
+(assert_eq (invoke "div_s" (i64.literal -7) (i64.literal 3)) (i64.literal -2))
+(assert_eq (invoke "div_s" (i64.literal 7) (i64.literal -3)) (i64.literal -2))
+(assert_eq (invoke "div_s" (i64.literal -7) (i64.literal -3)) (i64.literal 2))
+(assert_eq (invoke "div_s" (i64.literal 11) (i64.literal 5)) (i64.literal 2))
+(assert_eq (invoke "div_s" (i64.literal 17) (i64.literal 7)) (i64.literal 2))
 
 
-(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "runtime: integer divide by zero")
-(assert_eq (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_eq (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
-(assert_eq (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
-(assert_eq (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
-(assert_eq (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
-(assert_eq (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
-(assert_eq (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
-(assert_eq (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
-(assert_eq (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
-(assert_eq (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
-(assert_eq (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
+(assert_trap (invoke "div_u" (i64.literal 1) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "div_u" (i64.literal 0) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_eq (invoke "div_u" (i64.literal 1) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "div_u" (i64.literal 0) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "div_u" (i64.literal -1) (i64.literal -1)) (i64.literal 1))
+(assert_eq (invoke "div_u" (i64.literal 0x8000000000000000) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "div_u" (i64.literal 0x8000000000000000) (i64.literal 2)) (i64.literal 0x4000000000000000))
+(assert_eq (invoke "div_u" (i64.literal 0x8ff00ff00ff00ff0) (i64.literal 0x100000001)) (i64.literal 0x8ff00fef))
+(assert_eq (invoke "div_u" (i64.literal 0x8000000000000001) (i64.literal 1000)) (i64.literal 0x20c49ba5e353f7))
+(assert_eq (invoke "div_u" (i64.literal 5) (i64.literal 2)) (i64.literal 2))
+(assert_eq (invoke "div_u" (i64.literal -5) (i64.literal 2)) (i64.literal 0x7ffffffffffffffd))
+(assert_eq (invoke "div_u" (i64.literal 5) (i64.literal -2)) (i64.literal 0))
+(assert_eq (invoke "div_u" (i64.literal -5) (i64.literal -2)) (i64.literal 0))
+(assert_eq (invoke "div_u" (i64.literal 7) (i64.literal 3)) (i64.literal 2))
+(assert_eq (invoke "div_u" (i64.literal 11) (i64.literal 5)) (i64.literal 2))
+(assert_eq (invoke "div_u" (i64.literal 17) (i64.literal 7)) (i64.literal 2))
 
-(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "runtime: integer divide by zero")
-(assert_eq (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
-(assert_eq (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
-(assert_eq (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
-(assert_eq (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
-(assert_eq (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
-(assert_eq (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
-(assert_eq (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
-(assert_eq (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
-(assert_eq (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
-(assert_eq (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
-(assert_eq (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
-(assert_eq (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
+(assert_trap (invoke "rem_s" (i64.literal 1) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "rem_s" (i64.literal 0) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_eq (invoke "rem_s" (i64.literal 0x7fffffffffffffff) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "rem_s" (i64.literal 1) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "rem_s" (i64.literal 0) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "rem_s" (i64.literal -1) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "rem_s" (i64.literal 0x8000000000000000) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "rem_s" (i64.literal 0x8000000000000000) (i64.literal 2)) (i64.literal 0))
+(assert_eq (invoke "rem_s" (i64.literal 0x8000000000000001) (i64.literal 1000)) (i64.literal -807))
+(assert_eq (invoke "rem_s" (i64.literal 5) (i64.literal 2)) (i64.literal 1))
+(assert_eq (invoke "rem_s" (i64.literal -5) (i64.literal 2)) (i64.literal -1))
+(assert_eq (invoke "rem_s" (i64.literal 5) (i64.literal -2)) (i64.literal 1))
+(assert_eq (invoke "rem_s" (i64.literal -5) (i64.literal -2)) (i64.literal -1))
+(assert_eq (invoke "rem_s" (i64.literal 7) (i64.literal 3)) (i64.literal 1))
+(assert_eq (invoke "rem_s" (i64.literal -7) (i64.literal 3)) (i64.literal -1))
+(assert_eq (invoke "rem_s" (i64.literal 7) (i64.literal -3)) (i64.literal 1))
+(assert_eq (invoke "rem_s" (i64.literal -7) (i64.literal -3)) (i64.literal -1))
+(assert_eq (invoke "rem_s" (i64.literal 11) (i64.literal 5)) (i64.literal 1))
+(assert_eq (invoke "rem_s" (i64.literal 17) (i64.literal 7)) (i64.literal 3))
 
-(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "runtime: integer divide by zero")
-(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "runtime: integer divide by zero")
-(assert_eq (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
-(assert_eq (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
-(assert_eq (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
-(assert_eq (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
-(assert_eq (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
-(assert_eq (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
-(assert_eq (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
-(assert_eq (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
-(assert_eq (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
-(assert_eq (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
+(assert_trap (invoke "rem_u" (i64.literal 1) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_trap (invoke "rem_u" (i64.literal 0) (i64.literal 0)) "runtime: integer divide by zero")
+(assert_eq (invoke "rem_u" (i64.literal 1) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "rem_u" (i64.literal 0) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "rem_u" (i64.literal -1) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "rem_u" (i64.literal 0x8000000000000000) (i64.literal -1)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "rem_u" (i64.literal 0x8000000000000000) (i64.literal 2)) (i64.literal 0))
+(assert_eq (invoke "rem_u" (i64.literal 0x8ff00ff00ff00ff0) (i64.literal 0x100000001)) (i64.literal 0x80000001))
+(assert_eq (invoke "rem_u" (i64.literal 0x8000000000000001) (i64.literal 1000)) (i64.literal 809))
+(assert_eq (invoke "rem_u" (i64.literal 5) (i64.literal 2)) (i64.literal 1))
+(assert_eq (invoke "rem_u" (i64.literal -5) (i64.literal 2)) (i64.literal 1))
+(assert_eq (invoke "rem_u" (i64.literal 5) (i64.literal -2)) (i64.literal 5))
+(assert_eq (invoke "rem_u" (i64.literal -5) (i64.literal -2)) (i64.literal -5))
+(assert_eq (invoke "rem_u" (i64.literal 7) (i64.literal 3)) (i64.literal 1))
+(assert_eq (invoke "rem_u" (i64.literal 11) (i64.literal 5)) (i64.literal 1))
+(assert_eq (invoke "rem_u" (i64.literal 17) (i64.literal 7)) (i64.literal 3))
 
-(assert_eq (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_eq (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
-(assert_eq (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
-(assert_eq (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+(assert_eq (invoke "and" (i64.literal 1) (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "and" (i64.literal 0) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "and" (i64.literal 1) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "and" (i64.literal 0) (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "and" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i64.literal 0))
+(assert_eq (invoke "and" (i64.literal 0x7fffffffffffffff) (i64.literal -1)) (i64.literal 0x7fffffffffffffff))
+(assert_eq (invoke "and" (i64.literal 0xf0f0ffff) (i64.literal 0xfffff0f0)) (i64.literal 0xf0f0f0f0))
+(assert_eq (invoke "and" (i64.literal 0xffffffffffffffff) (i64.literal 0xffffffffffffffff)) (i64.literal 0xffffffffffffffff))
 
-(assert_eq (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
-(assert_eq (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
-(assert_eq (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+(assert_eq (invoke "or" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "or" (i64.literal 0) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "or" (i64.literal 1) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "or" (i64.literal 0) (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "or" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i64.literal -1))
+(assert_eq (invoke "or" (i64.literal 0x8000000000000000) (i64.literal 0)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "or" (i64.literal 0xf0f0ffff) (i64.literal 0xfffff0f0)) (i64.literal 0xffffffff))
+(assert_eq (invoke "or" (i64.literal 0xffffffffffffffff) (i64.literal 0xffffffffffffffff)) (i64.literal 0xffffffffffffffff))
 
-(assert_eq (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_eq (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
-(assert_eq (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
-(assert_eq (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
-(assert_eq (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
+(assert_eq (invoke "xor" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "xor" (i64.literal 0) (i64.literal 1)) (i64.literal 1))
+(assert_eq (invoke "xor" (i64.literal 1) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "xor" (i64.literal 0) (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "xor" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i64.literal -1))
+(assert_eq (invoke "xor" (i64.literal 0x8000000000000000) (i64.literal 0)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "xor" (i64.literal -1) (i64.literal 0x8000000000000000)) (i64.literal 0x7fffffffffffffff))
+(assert_eq (invoke "xor" (i64.literal -1) (i64.literal 0x7fffffffffffffff)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "xor" (i64.literal 0xf0f0ffff) (i64.literal 0xfffff0f0)) (i64.literal 0x0f0f0f0f))
+(assert_eq (invoke "xor" (i64.literal 0xffffffffffffffff) (i64.literal 0xffffffffffffffff)) (i64.literal 0))
 
-(assert_eq (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_eq (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
-(assert_eq (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
-(assert_eq (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
-(assert_eq (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 0))
-(assert_eq (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_eq (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal 1)) (i64.literal 2))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "shl" (i64.literal 0x7fffffffffffffff) (i64.literal 1)) (i64.literal 0xfffffffffffffffe))
+(assert_eq (invoke "shl" (i64.literal 0xffffffffffffffff) (i64.literal 1)) (i64.literal 0xfffffffffffffffe))
+(assert_eq (invoke "shl" (i64.literal 0x8000000000000000) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "shl" (i64.literal 0x4000000000000000) (i64.literal 1)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal 63)) (i64.literal 0x8000000000000000))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal 64)) (i64.literal 0))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal 65)) (i64.literal 0))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "shl" (i64.literal 1) (i64.literal 0x7fffffffffffffff)) (i64.literal 0))
 
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_eq (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
-(assert_eq (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
-(assert_eq (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 0))
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_eq (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_eq (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
-(assert_eq (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
-(assert_eq (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
-(assert_eq (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
-(assert_eq (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
-(assert_eq (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "shr_s" (i64.literal -1) (i64.literal 1)) (i64.literal -1))
+(assert_eq (invoke "shr_s" (i64.literal 0x7fffffffffffffff) (i64.literal 1)) (i64.literal 0x3fffffffffffffff))
+(assert_eq (invoke "shr_s" (i64.literal 0x8000000000000000) (i64.literal 1)) (i64.literal 0xc000000000000000))
+(assert_eq (invoke "shr_s" (i64.literal 0x4000000000000000) (i64.literal 1)) (i64.literal 0x2000000000000000))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal 64)) (i64.literal 0))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal 65)) (i64.literal 0))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal 0x7fffffffffffffff)) (i64.literal 0))
+(assert_eq (invoke "shr_s" (i64.literal 1) (i64.literal 0x8000000000000000)) (i64.literal 0))
+(assert_eq (invoke "shr_s" (i64.literal 0x8000000000000000) (i64.literal 63)) (i64.literal -1))
+(assert_eq (invoke "shr_s" (i64.literal -1) (i64.literal 64)) (i64.literal -1))
+(assert_eq (invoke "shr_s" (i64.literal -1) (i64.literal 65)) (i64.literal -1))
+(assert_eq (invoke "shr_s" (i64.literal -1) (i64.literal -1)) (i64.literal -1))
+(assert_eq (invoke "shr_s" (i64.literal -1) (i64.literal 0x7fffffffffffffff)) (i64.literal -1))
+(assert_eq (invoke "shr_s" (i64.literal -1) (i64.literal 0x8000000000000000)) (i64.literal -1))
 
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_eq (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
-(assert_eq (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
-(assert_eq (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
-(assert_eq (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
-(assert_eq (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_eq (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal 1)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal 0)) (i64.literal 1))
+(assert_eq (invoke "shr_u" (i64.literal -1) (i64.literal 1)) (i64.literal 0x7fffffffffffffff))
+(assert_eq (invoke "shr_u" (i64.literal 0x7fffffffffffffff) (i64.literal 1)) (i64.literal 0x3fffffffffffffff))
+(assert_eq (invoke "shr_u" (i64.literal 0x8000000000000000) (i64.literal 1)) (i64.literal 0x4000000000000000))
+(assert_eq (invoke "shr_u" (i64.literal 0x4000000000000000) (i64.literal 1)) (i64.literal 0x2000000000000000))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal 64)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal 65)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal 0x7fffffffffffffff)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal 1) (i64.literal 0x8000000000000000)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal 0x8000000000000000) (i64.literal 63)) (i64.literal 1))
+(assert_eq (invoke "shr_u" (i64.literal -1) (i64.literal 64)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal -1) (i64.literal 65)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal -1) (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal -1) (i64.literal 0x7fffffffffffffff)) (i64.literal 0))
+(assert_eq (invoke "shr_u" (i64.literal -1) (i64.literal 0x8000000000000000)) (i64.literal 0))
 
-(assert_eq (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
-(assert_eq (invoke "clz" (i64.const 0)) (i64.const 64))
-(assert_eq (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
-(assert_eq (invoke "clz" (i64.const 0xff)) (i64.const 56))
-(assert_eq (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_eq (invoke "clz" (i64.const 1)) (i64.const 63))
-(assert_eq (invoke "clz" (i64.const 2)) (i64.const 62))
+(assert_eq (invoke "clz" (i64.literal 0xffffffffffffffff)) (i64.literal 0))
+(assert_eq (invoke "clz" (i64.literal 0)) (i64.literal 64))
+(assert_eq (invoke "clz" (i64.literal 0x00008000)) (i64.literal 48))
+(assert_eq (invoke "clz" (i64.literal 0xff)) (i64.literal 56))
+(assert_eq (invoke "clz" (i64.literal 0x8000000000000000)) (i64.literal 0))
+(assert_eq (invoke "clz" (i64.literal 1)) (i64.literal 63))
+(assert_eq (invoke "clz" (i64.literal 2)) (i64.literal 62))
 
-(assert_eq (invoke "ctz" (i64.const -1)) (i64.const 0))
-(assert_eq (invoke "ctz" (i64.const 0)) (i64.const 64))
-(assert_eq (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
-(assert_eq (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
-(assert_eq (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
+(assert_eq (invoke "ctz" (i64.literal -1)) (i64.literal 0))
+(assert_eq (invoke "ctz" (i64.literal 0)) (i64.literal 64))
+(assert_eq (invoke "ctz" (i64.literal 0x00008000)) (i64.literal 15))
+(assert_eq (invoke "ctz" (i64.literal 0x00010000)) (i64.literal 16))
+(assert_eq (invoke "ctz" (i64.literal 0x8000000000000000)) (i64.literal 63))
 
-(assert_eq (invoke "popcnt" (i64.const -1)) (i64.const 64))
-(assert_eq (invoke "popcnt" (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
+(assert_eq (invoke "popcnt" (i64.literal -1)) (i64.literal 64))
+(assert_eq (invoke "popcnt" (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "popcnt" (i64.literal 0x00008000)) (i64.literal 1))
 
-(assert_eq (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_eq (invoke "eq" (i64.literal 0) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "eq" (i64.literal 1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "eq" (i64.literal -1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "eq" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "eq" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "eq" (i64.literal -1) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "eq" (i64.literal 1) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "eq" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "eq" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "eq" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
 
-(assert_eq (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_eq (invoke "ne" (i64.literal 0) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "ne" (i64.literal 1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ne" (i64.literal -1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ne" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "ne" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "ne" (i64.literal -1) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ne" (i64.literal 1) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ne" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ne" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "ne" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
 
-(assert_eq (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_eq (invoke "lt_s" (i64.literal 0) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal 1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal -1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal -1) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal 1) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal 0) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "lt_s" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "lt_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 0))
 
-(assert_eq (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_eq (invoke "lt_u" (i64.literal 0) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal -1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal -1) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 1) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 0) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "lt_u" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "lt_u" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "lt_u" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "lt_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 1))
 
-(assert_eq (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_eq (invoke "le_s" (i64.literal 0) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal -1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal -1) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 1) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "le_s" (i64.literal 0) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "le_s" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "le_s" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "le_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 0))
 
-(assert_eq (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_eq (invoke "le_u" (i64.literal 0) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal 1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal -1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal -1) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal 1) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i64.literal 0) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "le_u" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "le_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 1))
 
-(assert_eq (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_eq (invoke "gt_s" (i64.literal 0) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal -1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal -1) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 1) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "gt_s" (i64.literal 0) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "gt_s" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "gt_s" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "gt_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 1))
 
-(assert_eq (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_eq (invoke "gt_u" (i64.literal 0) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal 1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal -1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal -1) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal 1) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i64.literal 0) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "gt_u" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "gt_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 0))
 
-(assert_eq (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_eq (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_eq (invoke "ge_s" (i64.literal 0) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal 1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal -1) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal -1) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal 1) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal 0) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "ge_s" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 0))
+(assert_eq (invoke "ge_s" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 1))
 
-(assert_eq (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_eq (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_eq (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_eq (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_eq (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_eq (invoke "ge_u" (i64.literal 0) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal -1) (i64.literal 1)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 0x8000000000000000) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal -1) (i64.literal -1)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 1) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 0) (i64.literal 1)) (i32.literal 0))
+(assert_eq (invoke "ge_u" (i64.literal 0x8000000000000000) (i64.literal 0)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 0) (i64.literal 0x8000000000000000)) (i32.literal 0))
+(assert_eq (invoke "ge_u" (i64.literal 0x8000000000000000) (i64.literal -1)) (i32.literal 0))
+(assert_eq (invoke "ge_u" (i64.literal -1) (i64.literal 0x8000000000000000)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 0x8000000000000000) (i64.literal 0x7fffffffffffffff)) (i32.literal 1))
+(assert_eq (invoke "ge_u" (i64.literal 0x7fffffffffffffff) (i64.literal 0x8000000000000000)) (i32.literal 0))
diff --git a/ml-proto/test/imports.wasm b/ml-proto/test/imports.wasm
index e086314e4a..0e17fbb98b 100644
--- a/ml-proto/test/imports.wasm
+++ b/ml-proto/test/imports.wasm
@@ -4,11 +4,11 @@
     (func $print (param $i i32)
         (call_import $print_i32 (get_local $i))
         (call_import $print_i32_f32
-            (i32.add (get_local $i) (i32.const 1))
-            (f32.const 42)
+            (i32.add (get_local $i) (i32.literal 1))
+            (f32.literal 42)
         )
     )
     (export "print" $print)
 )
 
-(invoke "print" (i32.const 13))
+(invoke "print" (i32.literal 13))
diff --git a/ml-proto/test/memory.wasm b/ml-proto/test/memory.wasm
index d2a35f9744..7cdb720157 100644
--- a/ml-proto/test/memory.wasm
+++ b/ml-proto/test/memory.wasm
@@ -35,29 +35,29 @@
 )
 
 ;; Test alignment annotation rules
-(module (func (i32.load8_u/2 (i32.const 0))))
-(module (func (i32.load16_u/4 (i32.const 0))))
-(module (func (i32.load/8 (i32.const 0))))
-(module (func (f32.load/8 (i32.const 0))))
+(module (func (i32.load8_u/2 (i32.literal 0))))
+(module (func (i32.load16_u/4 (i32.literal 0))))
+(module (func (i32.load/8 (i32.literal 0))))
+(module (func (f32.load/8 (i32.literal 0))))
 
 (assert_invalid
-  (module (func (i64.load/0 (i32.const 0))))
+  (module (func (i64.load/0 (i32.literal 0))))
   "non-power-of-two alignment"
 )
 (assert_invalid
-  (module (func (i64.load/3 (i32.const 0))))
+  (module (func (i64.load/3 (i32.literal 0))))
   "non-power-of-two alignment"
 )
 (assert_invalid
-  (module (func (i64.load/5 (i32.const 0))))
+  (module (func (i64.load/5 (i32.literal 0))))
   "non-power-of-two alignment"
 )
 (assert_invalid
-  (module (func (i64.load/6 (i32.const 0))))
+  (module (func (i64.load/6 (i32.literal 0))))
   "non-power-of-two alignment"
 )
 (assert_invalid
-  (module (func (i64.load/7 (i32.const 0))))
+  (module (func (i64.load/7 (i32.literal 0))))
   "non-power-of-two alignment"
 )
 
@@ -68,12 +68,12 @@
   (func $data (result i32)
     (i32.and
       (i32.and
-        (i32.eq (i32.load8_u (i32.const 0)) (i32.const 65))
-        (i32.eq (i32.load8_u (i32.const 3)) (i32.const 167))
+        (i32.eq (i32.load8_u (i32.literal 0)) (i32.literal 65))
+        (i32.eq (i32.load8_u (i32.literal 3)) (i32.literal 167))
       )
       (i32.and
-        (i32.eq (i32.load8_u (i32.const 20)) (i32.const 87))
-        (i32.eq (i32.load8_u (i32.const 23)) (i32.const 77))
+        (i32.eq (i32.load8_u (i32.literal 20)) (i32.literal 87))
+        (i32.eq (i32.load8_u (i32.literal 23)) (i32.literal 77))
       )
     )
   )
@@ -81,34 +81,34 @@
   ;; Aligned read/write
   (func $aligned (result i32)
     (local i32 i32 i32)
-    (set_local 0 (i32.const 10))
+    (set_local 0 (i32.literal 10))
     (label
       (loop
         (if
-          (i32.eq (get_local 0) (i32.const 0))
+          (i32.eq (get_local 0) (i32.literal 0))
           (break)
         )
-        (set_local 2 (i32.mul (get_local 0) (i32.const 4)))
+        (set_local 2 (i32.mul (get_local 0) (i32.literal 4)))
         (i32.store (get_local 2) (get_local 0))
         (set_local 1 (i32.load (get_local 2)))
         (if
           (i32.ne (get_local 0) (get_local 1))
-          (return (i32.const 0))
+          (return (i32.literal 0))
         )
-        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
+        (set_local 0 (i32.sub (get_local 0) (i32.literal 1)))
       )
     )
-    (return (i32.const 1))
+    (return (i32.literal 1))
   )
 
   ;; Unaligned read/write
   (func $unaligned (result i32)
     (local i32 f64 f64)
-    (set_local 0 (i32.const 10))
+    (set_local 0 (i32.literal 10))
     (label
       (loop
         (if
-          (i32.eq (get_local 0) (i32.const 0))
+          (i32.eq (get_local 0) (i32.literal 0))
           (break)
         )
         (set_local 2 (f64.convert_s/i32 (get_local 0)))
@@ -116,69 +116,69 @@
         (set_local 1 (f64.load/1 (get_local 0)))
         (if
           (f64.ne (get_local 2) (get_local 1))
-          (return (i32.const 0))
+          (return (i32.literal 0))
         )
-        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
+        (set_local 0 (i32.sub (get_local 0) (i32.literal 1)))
       )
     )
-    (return (i32.const 1))
+    (return (i32.literal 1))
   )
 
   ;; Memory cast
   (func $cast (result f64)
-    (i64.store (i32.const 8) (i64.const -12345))
+    (i64.store (i32.literal 8) (i64.literal -12345))
     (if
       (f64.eq
-        (f64.load (i32.const 8))
-        (f64.reinterpret/i64 (i64.const -12345))
+        (f64.load (i32.literal 8))
+        (f64.reinterpret/i64 (i64.literal -12345))
       )
-      (return (f64.const 0))
+      (return (f64.literal 0))
     )
-    (i64.store/1 (i32.const 9) (i64.const 0))
-    (i32.store16/1 (i32.const 15) (i32.const 16453))
-    (return (f64.load/1 (i32.const 9)))
+    (i64.store/1 (i32.literal 9) (i64.literal 0))
+    (i32.store16/1 (i32.literal 15) (i32.literal 16453))
+    (return (f64.load/1 (i32.literal 9)))
   )
 
   ;; Sign and zero extending memory loads
   (func $i32_load8_s (param $i i32) (result i32)
-	(i32.store8 (i32.const 8) (get_local $i))
-	(return (i32.load8_s (i32.const 8)))
+	(i32.store8 (i32.literal 8) (get_local $i))
+	(return (i32.load8_s (i32.literal 8)))
   )
   (func $i32_load8_u (param $i i32) (result i32)
-	(i32.store8 (i32.const 8) (get_local $i))
-	(return (i32.load8_u (i32.const 8)))
+	(i32.store8 (i32.literal 8) (get_local $i))
+	(return (i32.load8_u (i32.literal 8)))
   )
   (func $i32_load16_s (param $i i32) (result i32)
-	(i32.store16 (i32.const 8) (get_local $i))
-	(return (i32.load16_s (i32.const 8)))
+	(i32.store16 (i32.literal 8) (get_local $i))
+	(return (i32.load16_s (i32.literal 8)))
   )
   (func $i32_load16_u (param $i i32) (result i32)
-	(i32.store16 (i32.const 8) (get_local $i))
-	(return (i32.load16_u (i32.const 8)))
+	(i32.store16 (i32.literal 8) (get_local $i))
+	(return (i32.load16_u (i32.literal 8)))
   )
   (func $i64_load8_s (param $i i64) (result i64)
-	(i64.store8 (i32.const 8) (get_local $i))
-	(return (i64.load8_s (i32.const 8)))
+	(i64.store8 (i32.literal 8) (get_local $i))
+	(return (i64.load8_s (i32.literal 8)))
   )
   (func $i64_load8_u (param $i i64) (result i64)
-	(i64.store8 (i32.const 8) (get_local $i))
-	(return (i64.load8_u (i32.const 8)))
+	(i64.store8 (i32.literal 8) (get_local $i))
+	(return (i64.load8_u (i32.literal 8)))
   )
   (func $i64_load16_s (param $i i64) (result i64)
-	(i64.store16 (i32.const 8) (get_local $i))
-	(return (i64.load16_s (i32.const 8)))
+	(i64.store16 (i32.literal 8) (get_local $i))
+	(return (i64.load16_s (i32.literal 8)))
   )
   (func $i64_load16_u (param $i i64) (result i64)
-	(i64.store16 (i32.const 8) (get_local $i))
-	(return (i64.load16_u (i32.const 8)))
+	(i64.store16 (i32.literal 8) (get_local $i))
+	(return (i64.load16_u (i32.literal 8)))
   )
   (func $i64_load32_s (param $i i64) (result i64)
-	(i64.store32 (i32.const 8) (get_local $i))
-	(return (i64.load32_s (i32.const 8)))
+	(i64.store32 (i32.literal 8) (get_local $i))
+	(return (i64.load32_s (i32.literal 8)))
   )
   (func $i64_load32_u (param $i i64) (result i64)
-	(i64.store32 (i32.const 8) (get_local $i))
-	(return (i64.load32_u (i32.const 8)))
+	(i64.store32 (i32.literal 8) (get_local $i))
+	(return (i64.load32_u (i32.literal 8)))
   )
 
   (export "data" $data)
@@ -197,31 +197,31 @@
   (export "i64_load32_u" $i64_load32_u)
 )
 
-(assert_eq (invoke "data") (i32.const 1))
-(assert_eq (invoke "aligned") (i32.const 1))
-(assert_eq (invoke "unaligned") (i32.const 1))
-(assert_eq (invoke "cast") (f64.const 42.0))
-
-(assert_eq (invoke "i32_load8_s" (i32.const -1)) (i32.const -1))
-(assert_eq (invoke "i32_load8_u" (i32.const -1)) (i32.const 255))
-(assert_eq (invoke "i32_load16_s" (i32.const -1)) (i32.const -1))
-(assert_eq (invoke "i32_load16_u" (i32.const -1)) (i32.const 65535))
-
-(assert_eq (invoke "i32_load8_s" (i32.const 100)) (i32.const 100))
-(assert_eq (invoke "i32_load8_u" (i32.const 200)) (i32.const 200))
-(assert_eq (invoke "i32_load16_s" (i32.const 20000)) (i32.const 20000))
-(assert_eq (invoke "i32_load16_u" (i32.const 40000)) (i32.const 40000))
-
-(assert_eq (invoke "i64_load8_s" (i64.const -1)) (i64.const -1))
-(assert_eq (invoke "i64_load8_u" (i64.const -1)) (i64.const 255))
-(assert_eq (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
-(assert_eq (invoke "i64_load16_u" (i64.const -1)) (i64.const 65535))
-(assert_eq (invoke "i64_load32_s" (i64.const -1)) (i64.const -1))
-(assert_eq (invoke "i64_load32_u" (i64.const -1)) (i64.const 4294967295))
-
-(assert_eq (invoke "i64_load8_s" (i64.const 100)) (i64.const 100))
-(assert_eq (invoke "i64_load8_u" (i64.const 200)) (i64.const 200))
-(assert_eq (invoke "i64_load16_s" (i64.const 20000)) (i64.const 20000))
-(assert_eq (invoke "i64_load16_u" (i64.const 40000)) (i64.const 40000))
-(assert_eq (invoke "i64_load32_s" (i64.const 20000)) (i64.const 20000))
-(assert_eq (invoke "i64_load32_u" (i64.const 40000)) (i64.const 40000))
+(assert_eq (invoke "data") (i32.literal 1))
+(assert_eq (invoke "aligned") (i32.literal 1))
+(assert_eq (invoke "unaligned") (i32.literal 1))
+(assert_eq (invoke "cast") (f64.literal 42.0))
+
+(assert_eq (invoke "i32_load8_s" (i32.literal -1)) (i32.literal -1))
+(assert_eq (invoke "i32_load8_u" (i32.literal -1)) (i32.literal 255))
+(assert_eq (invoke "i32_load16_s" (i32.literal -1)) (i32.literal -1))
+(assert_eq (invoke "i32_load16_u" (i32.literal -1)) (i32.literal 65535))
+
+(assert_eq (invoke "i32_load8_s" (i32.literal 100)) (i32.literal 100))
+(assert_eq (invoke "i32_load8_u" (i32.literal 200)) (i32.literal 200))
+(assert_eq (invoke "i32_load16_s" (i32.literal 20000)) (i32.literal 20000))
+(assert_eq (invoke "i32_load16_u" (i32.literal 40000)) (i32.literal 40000))
+
+(assert_eq (invoke "i64_load8_s" (i64.literal -1)) (i64.literal -1))
+(assert_eq (invoke "i64_load8_u" (i64.literal -1)) (i64.literal 255))
+(assert_eq (invoke "i64_load16_s" (i64.literal -1)) (i64.literal -1))
+(assert_eq (invoke "i64_load16_u" (i64.literal -1)) (i64.literal 65535))
+(assert_eq (invoke "i64_load32_s" (i64.literal -1)) (i64.literal -1))
+(assert_eq (invoke "i64_load32_u" (i64.literal -1)) (i64.literal 4294967295))
+
+(assert_eq (invoke "i64_load8_s" (i64.literal 100)) (i64.literal 100))
+(assert_eq (invoke "i64_load8_u" (i64.literal 200)) (i64.literal 200))
+(assert_eq (invoke "i64_load16_s" (i64.literal 20000)) (i64.literal 20000))
+(assert_eq (invoke "i64_load16_u" (i64.literal 40000)) (i64.literal 40000))
+(assert_eq (invoke "i64_load32_s" (i64.literal 20000)) (i64.literal 20000))
+(assert_eq (invoke "i64_load32_u" (i64.literal 40000)) (i64.literal 40000))
diff --git a/ml-proto/test/memory_trap.wasm b/ml-proto/test/memory_trap.wasm
index ca00f5a9dd..a9e3043552 100644
--- a/ml-proto/test/memory_trap.wasm
+++ b/ml-proto/test/memory_trap.wasm
@@ -8,11 +8,11 @@
     (func $load (param $i i32) (result i32) (i32.load (get_local $i)))
 )
 
-(invoke "store" (i32.const 96) (i32.const 42))
-(assert_eq (invoke "load" (i32.const 96)) (i32.const 42))
-(assert_trap (invoke "store" (i32.const 97) (i32.const 13)) "runtime: out of bounds memory access")
-(assert_trap (invoke "load" (i32.const 97)) "runtime: out of bounds memory access")
-(assert_trap (invoke "store" (i32.const 98) (i32.const 13)) "runtime: out of bounds memory access")
-(assert_trap (invoke "load" (i32.const 98)) "runtime: out of bounds memory access")
-(assert_trap (invoke "store" (i32.const 99) (i32.const 13)) "runtime: out of bounds memory access")
-(assert_trap (invoke "load" (i32.const 99)) "runtime: out of bounds memory access")
+(invoke "store" (i32.literal 96) (i32.literal 42))
+(assert_eq (invoke "load" (i32.literal 96)) (i32.literal 42))
+(assert_trap (invoke "store" (i32.literal 97) (i32.literal 13)) "runtime: out of bounds memory access")
+(assert_trap (invoke "load" (i32.literal 97)) "runtime: out of bounds memory access")
+(assert_trap (invoke "store" (i32.literal 98) (i32.literal 13)) "runtime: out of bounds memory access")
+(assert_trap (invoke "load" (i32.literal 98)) "runtime: out of bounds memory access")
+(assert_trap (invoke "store" (i32.literal 99) (i32.literal 13)) "runtime: out of bounds memory access")
+(assert_trap (invoke "load" (i32.literal 99)) "runtime: out of bounds memory access")
diff --git a/ml-proto/test/resizing.wasm b/ml-proto/test/resizing.wasm
index 63e53cc041..697e9904a4 100644
--- a/ml-proto/test/resizing.wasm
+++ b/ml-proto/test/resizing.wasm
@@ -14,19 +14,19 @@
     (func $size (result i32) (memory_size))
 )
 
-(assert_eq (invoke "size") (i32.const 4096))
-(invoke "store" (i32.const 0) (i32.const 42))
-(assert_eq (invoke "load" (i32.const 0)) (i32.const 42))
-(assert_trap (invoke "store" (i32.const 4096) (i32.const 42)) "runtime: out of bounds memory access")
-(assert_trap (invoke "load" (i32.const 4096)) "runtime: out of bounds memory access")
-(invoke "resize" (i32.const 8192))
-(assert_eq (invoke "size") (i32.const 8192))
-(assert_eq (invoke "load" (i32.const 0)) (i32.const 42))
-(assert_eq (invoke "load" (i32.const 4096)) (i32.const 0))
-(invoke "store" (i32.const 4096) (i32.const 43))
-(assert_eq (invoke "load" (i32.const 4096)) (i32.const 43))
-(invoke "resize" (i32.const 4096))
-(assert_eq (invoke "size") (i32.const 4096))
-(assert_eq (invoke "load" (i32.const 0)) (i32.const 42))
-(assert_trap (invoke "store" (i32.const 4096) (i32.const 42)) "runtime: out of bounds memory access")
-(assert_trap (invoke "load" (i32.const 4096)) "runtime: out of bounds memory access")
+(assert_eq (invoke "size") (i32.literal 4096))
+(invoke "store" (i32.literal 0) (i32.literal 42))
+(assert_eq (invoke "load" (i32.literal 0)) (i32.literal 42))
+(assert_trap (invoke "store" (i32.literal 4096) (i32.literal 42)) "runtime: out of bounds memory access")
+(assert_trap (invoke "load" (i32.literal 4096)) "runtime: out of bounds memory access")
+(invoke "resize" (i32.literal 8192))
+(assert_eq (invoke "size") (i32.literal 8192))
+(assert_eq (invoke "load" (i32.literal 0)) (i32.literal 42))
+(assert_eq (invoke "load" (i32.literal 4096)) (i32.literal 0))
+(invoke "store" (i32.literal 4096) (i32.literal 43))
+(assert_eq (invoke "load" (i32.literal 4096)) (i32.literal 43))
+(invoke "resize" (i32.literal 4096))
+(assert_eq (invoke "size") (i32.literal 4096))
+(assert_eq (invoke "load" (i32.literal 0)) (i32.literal 42))
+(assert_trap (invoke "store" (i32.literal 4096) (i32.literal 42)) "runtime: out of bounds memory access")
+(assert_trap (invoke "load" (i32.literal 4096)) "runtime: out of bounds memory access")
diff --git a/ml-proto/test/switch.wasm b/ml-proto/test/switch.wasm
index df8f0172fc..7539ffcd89 100644
--- a/ml-proto/test/switch.wasm
+++ b/ml-proto/test/switch.wasm
@@ -4,17 +4,17 @@
   ;; Statement switch
   (func $stmt (param $i i32) (result i32)
     (local $j i32)
-    (set_local $j (i32.const 100))
+    (set_local $j (i32.literal 100))
     (label
       (i32.switch (get_local $i)
         (case 0 (return (get_local $i)))
         (case 1 (nop) fallthrough)
         (case 2)  ;; implicit fallthrough
-        (case 3 (set_local $j (i32.sub (i32.const 0) (get_local $i))) (break))
+        (case 3 (set_local $j (i32.sub (i32.literal 0) (get_local $i))) (break))
         (case 4 (break))
-        (case 5 (set_local $j (i32.const 101)))
-        (case 6 (set_local $j (i32.const 101)) fallthrough)
-        (;default;) (set_local $j (i32.const 102))
+        (case 5 (set_local $j (i32.literal 101)))
+        (case 6 (set_local $j (i32.literal 101)) fallthrough)
+        (;default;) (set_local $j (i32.literal 102))
       )
     )
     (return (get_local $j))
@@ -23,15 +23,15 @@
   ;; Expression switch
   (func $expr (param $i i64) (result i64)
     (local $j i64)
-    (set_local $j (i64.const 100))
+    (set_local $j (i64.literal 100))
     (return
       (label $l
         (i64.switch (get_local $i)
           (case 0 (return (get_local $i)))
           (case 1 (nop) fallthrough)
           (case 2)  ;; implicit fallthrough
-          (case 3 (break $l (i64.sub (i64.const 0) (get_local $i))))
-          (case 6 (set_local $j (i64.const 101)) fallthrough)
+          (case 3 (break $l (i64.sub (i64.literal 0) (get_local $i))))
+          (case 6 (set_local $j (i64.literal 101)) fallthrough)
           (;default;) (get_local $j)
         )
       )
@@ -42,20 +42,20 @@
   (export "expr" $expr)
 )
 
-(assert_eq (invoke "stmt" (i32.const 0)) (i32.const 0))
-(assert_eq (invoke "stmt" (i32.const 1)) (i32.const -1))
-(assert_eq (invoke "stmt" (i32.const 2)) (i32.const -2))
-(assert_eq (invoke "stmt" (i32.const 3)) (i32.const -3))
-(assert_eq (invoke "stmt" (i32.const 4)) (i32.const 100))
-(assert_eq (invoke "stmt" (i32.const 5)) (i32.const 101))
-(assert_eq (invoke "stmt" (i32.const 6)) (i32.const 102))
-(assert_eq (invoke "stmt" (i32.const 7)) (i32.const 102))
-(assert_eq (invoke "stmt" (i32.const -10)) (i32.const 102))
+(assert_eq (invoke "stmt" (i32.literal 0)) (i32.literal 0))
+(assert_eq (invoke "stmt" (i32.literal 1)) (i32.literal -1))
+(assert_eq (invoke "stmt" (i32.literal 2)) (i32.literal -2))
+(assert_eq (invoke "stmt" (i32.literal 3)) (i32.literal -3))
+(assert_eq (invoke "stmt" (i32.literal 4)) (i32.literal 100))
+(assert_eq (invoke "stmt" (i32.literal 5)) (i32.literal 101))
+(assert_eq (invoke "stmt" (i32.literal 6)) (i32.literal 102))
+(assert_eq (invoke "stmt" (i32.literal 7)) (i32.literal 102))
+(assert_eq (invoke "stmt" (i32.literal -10)) (i32.literal 102))
 
-(assert_eq (invoke "expr" (i64.const 0)) (i64.const 0))
-(assert_eq (invoke "expr" (i64.const 1)) (i64.const -1))
-(assert_eq (invoke "expr" (i64.const 2)) (i64.const -2))
-(assert_eq (invoke "expr" (i64.const 3)) (i64.const -3))
-(assert_eq (invoke "expr" (i64.const 6)) (i64.const 101))
-(assert_eq (invoke "expr" (i64.const 7)) (i64.const 100))
-(assert_eq (invoke "expr" (i64.const -10)) (i64.const 100))
+(assert_eq (invoke "expr" (i64.literal 0)) (i64.literal 0))
+(assert_eq (invoke "expr" (i64.literal 1)) (i64.literal -1))
+(assert_eq (invoke "expr" (i64.literal 2)) (i64.literal -2))
+(assert_eq (invoke "expr" (i64.literal 3)) (i64.literal -3))
+(assert_eq (invoke "expr" (i64.literal 6)) (i64.literal 101))
+(assert_eq (invoke "expr" (i64.literal 7)) (i64.literal 100))
+(assert_eq (invoke "expr" (i64.literal -10)) (i64.literal 100))